<Uri>https://github.com/dotnet/arcade</Uri>
<Sha>4f645e4a5385eb96cad3f72f5ded239761c7d075</Sha>
</Dependency>
- <Dependency Name="Microsoft.Private.CoreFx.NETCoreApp" Version="4.6.0-preview5.19208.1">
+ <Dependency Name="Microsoft.Private.CoreFx.NETCoreApp" Version="4.6.0-preview5.19211.22">
<Uri>https://github.com/dotnet/corefx</Uri>
- <Sha>87fdc75beacc76e02c8e572ae3b0613b418200eb</Sha>
+ <Sha>fe5c12ad8315e043e62285117a56bba1784756d1</Sha>
</Dependency>
- <Dependency Name="Microsoft.NETCore.Platforms" Version="3.0.0-preview5.19208.1">
+ <Dependency Name="Microsoft.NETCore.Platforms" Version="3.0.0-preview5.19211.22">
<Uri>https://github.com/dotnet/corefx</Uri>
- <Sha>87fdc75beacc76e02c8e572ae3b0613b418200eb</Sha>
+ <Sha>fe5c12ad8315e043e62285117a56bba1784756d1</Sha>
</Dependency>
<Dependency Name="Microsoft.NETCore.App" Version="3.0.0-preview5-27610-11">
<Uri>https://github.com/dotnet/core-setup</Uri>
<UsingToolNetFrameworkReferenceAssemblies>true</UsingToolNetFrameworkReferenceAssemblies>
<MicrosoftDotNetXUnitConsoleRunnerVersion>2.5.1-beta.19179.4</MicrosoftDotNetXUnitConsoleRunnerVersion>
<MicrosoftNetFrameworkReferenceAssembliesVersion>1.0.0-alpha-004</MicrosoftNetFrameworkReferenceAssembliesVersion>
- <MicrosoftPrivateCoreFxNETCoreAppVersion>4.6.0-preview5.19208.1</MicrosoftPrivateCoreFxNETCoreAppVersion>
- <MicrosoftNETCorePlatformsVersion>3.0.0-preview5.19208.1</MicrosoftNETCorePlatformsVersion>
+ <MicrosoftPrivateCoreFxNETCoreAppVersion>4.6.0-preview5.19211.22</MicrosoftPrivateCoreFxNETCoreAppVersion>
+ <MicrosoftNETCorePlatformsVersion>3.0.0-preview5.19211.22</MicrosoftNETCorePlatformsVersion>
<MicrosoftNETCoreAppVersion>3.0.0-preview5-27610-11</MicrosoftNETCoreAppVersion>
<optimizationIBCCoreCLRVersion>99.99.99-master-20190313.3</optimizationIBCCoreCLRVersion>
<optimizationPGOCoreCLRVersion>99.99.99-master-20190313.3</optimizationPGOCoreCLRVersion>
/// __m256i _mm256_cvtepu8_epi16 (__m128i a)
/// VPMOVZXBW ymm, xmm
/// </summary>
- public static Vector256<ushort> ConvertToVector256UInt16(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
public static Vector256<short> ConvertToVector256Int16(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m256i _mm256_cvtepi8_epi32 (__m128i a)
/// __m256i _mm256_cvtepu8_epi32 (__m128i a)
/// VPMOVZXBD ymm, xmm
/// </summary>
- public static Vector256<uint> ConvertToVector256UInt32(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
public static Vector256<int> ConvertToVector256Int32(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m256i _mm256_cvtepi16_epi32 (__m128i a)
/// __m256i _mm256_cvtepu16_epi32 (__m128i a)
/// VPMOVZXWD ymm, xmm
/// </summary>
- public static Vector256<uint> ConvertToVector256UInt32(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
public static Vector256<int> ConvertToVector256Int32(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m256i _mm256_cvtepi8_epi64 (__m128i a)
/// __m256i _mm256_cvtepu8_epi64 (__m128i a)
/// VPMOVZXBQ ymm, xmm
/// </summary>
- public static Vector256<ulong> ConvertToVector256UInt64(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
public static Vector256<long> ConvertToVector256Int64(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m256i _mm256_cvtepi16_epi64 (__m128i a)
/// __m256i _mm256_cvtepu16_epi64 (__m128i a)
/// VPMOVZXWQ ymm, xmm
/// </summary>
- public static Vector256<ulong> ConvertToVector256UInt64(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
public static Vector256<long> ConvertToVector256Int64(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m256i _mm256_cvtepi32_epi64 (__m128i a)
/// __m256i _mm256_cvtepu32_epi64 (__m128i a)
/// VPMOVZXDQ ymm, xmm
/// </summary>
- public static Vector256<ulong> ConvertToVector256UInt64(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
public static Vector256<long> ConvertToVector256Int64(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m256i _mm256_cvtepu8_epi16 (__m128i a)
/// VPMOVZXBW ymm, xmm
/// </summary>
- public static Vector256<ushort> ConvertToVector256UInt16(Vector128<byte> value) => ConvertToVector256UInt16(value);
public static Vector256<short> ConvertToVector256Int16(Vector128<byte> value) => ConvertToVector256Int16(value);
/// <summary>
/// __m256i _mm256_cvtepi8_epi32 (__m128i a)
/// __m256i _mm256_cvtepu8_epi32 (__m128i a)
/// VPMOVZXBD ymm, xmm
/// </summary>
- public static Vector256<uint> ConvertToVector256UInt32(Vector128<byte> value) => ConvertToVector256UInt32(value);
public static Vector256<int> ConvertToVector256Int32(Vector128<byte> value) => ConvertToVector256Int32(value);
/// <summary>
/// __m256i _mm256_cvtepi16_epi32 (__m128i a)
/// __m256i _mm256_cvtepu16_epi32 (__m128i a)
/// VPMOVZXWD ymm, xmm
/// </summary>
- public static Vector256<uint> ConvertToVector256UInt32(Vector128<ushort> value) => ConvertToVector256UInt32(value);
public static Vector256<int> ConvertToVector256Int32(Vector128<ushort> value) => ConvertToVector256Int32(value);
/// <summary>
/// __m256i _mm256_cvtepi8_epi64 (__m128i a)
/// __m256i _mm256_cvtepu8_epi64 (__m128i a)
/// VPMOVZXBQ ymm, xmm
/// </summary>
- public static Vector256<ulong> ConvertToVector256UInt64(Vector128<byte> value) => ConvertToVector256UInt64(value);
public static Vector256<long> ConvertToVector256Int64(Vector128<byte> value) => ConvertToVector256Int64(value);
/// <summary>
/// __m256i _mm256_cvtepi16_epi64 (__m128i a)
/// __m256i _mm256_cvtepu16_epi64 (__m128i a)
/// VPMOVZXWQ ymm, xmm
/// </summary>
- public static Vector256<ulong> ConvertToVector256UInt64(Vector128<ushort> value) => ConvertToVector256UInt64(value);
public static Vector256<long> ConvertToVector256Int64(Vector128<ushort> value) => ConvertToVector256Int64(value);
/// <summary>
/// __m256i _mm256_cvtepi32_epi64 (__m128i a)
/// __m256i _mm256_cvtepu32_epi64 (__m128i a)
/// VPMOVZXDQ ymm, xmm
/// </summary>
- public static Vector256<ulong> ConvertToVector256UInt64(Vector128<uint> value) => ConvertToVector256UInt64(value);
public static Vector256<long> ConvertToVector256Int64(Vector128<uint> value) => ConvertToVector256Int64(value);
/// <summary>
/// int _mm_comieq_ss (__m128 a, __m128 b)
/// COMISS xmm, xmm/m32
/// </summary>
- public static bool CompareEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarOrderedEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_ucomieq_ss (__m128 a, __m128 b)
/// UCOMISS xmm, xmm/m32
/// </summary>
- public static bool CompareEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarUnorderedEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128 _mm_cmpeq_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(0)
/// </summary>
- public static Vector128<float> CompareEqualScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static Vector128<float> CompareScalarEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_comigt_ss (__m128 a, __m128 b)
/// COMISS xmm, xmm/m32
/// </summary>
- public static bool CompareGreaterThanOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarOrderedGreaterThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_ucomigt_ss (__m128 a, __m128 b)
/// UCOMISS xmm, xmm/m32
/// </summary>
- public static bool CompareGreaterThanUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarUnorderedGreaterThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128 _mm_cmpgt_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(6)
/// </summary>
- public static Vector128<float> CompareGreaterThanScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static Vector128<float> CompareScalarGreaterThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_comige_ss (__m128 a, __m128 b)
/// COMISS xmm, xmm/m32
/// </summary>
- public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarOrderedGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_ucomige_ss (__m128 a, __m128 b)
/// UCOMISS xmm, xmm/m32
/// </summary>
- public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarUnorderedGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128 _mm_cmpge_ss (__m128 a, __m128 b)
/// CMPPS xmm, xmm/m32, imm8(5)
/// </summary>
- public static Vector128<float> CompareGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static Vector128<float> CompareScalarGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_comilt_ss (__m128 a, __m128 b)
/// COMISS xmm, xmm/m32
/// </summary>
- public static bool CompareLessThanOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarOrderedLessThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_ucomilt_ss (__m128 a, __m128 b)
/// UCOMISS xmm, xmm/m32
/// </summary>
- public static bool CompareLessThanUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarUnorderedLessThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128 _mm_cmplt_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(1)
/// </summary>
- public static Vector128<float> CompareLessThanScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static Vector128<float> CompareScalarLessThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_comile_ss (__m128 a, __m128 b)
/// COMISS xmm, xmm/m32
/// </summary>
- public static bool CompareLessThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarOrderedLessThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_ucomile_ss (__m128 a, __m128 b)
/// UCOMISS xmm, xmm/m32
/// </summary>
- public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarUnorderedLessThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128 _mm_cmple_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(2)
/// </summary>
- public static Vector128<float> CompareLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static Vector128<float> CompareScalarLessThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_comineq_ss (__m128 a, __m128 b)
/// COMISS xmm, xmm/m32
/// </summary>
- public static bool CompareNotEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarOrderedNotEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_ucomineq_ss (__m128 a, __m128 b)
/// UCOMISS xmm, xmm/m32
/// </summary>
- public static bool CompareNotEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarUnorderedNotEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128 _mm_cmpneq_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(4)
/// </summary>
- public static Vector128<float> CompareNotEqualScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static Vector128<float> CompareScalarNotEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128 _mm_cmpngt_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(2)
/// </summary>
- public static Vector128<float> CompareNotGreaterThanScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static Vector128<float> CompareScalarNotGreaterThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128 _mm_cmpnge_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(1)
/// </summary>
- public static Vector128<float> CompareNotGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static Vector128<float> CompareScalarNotGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128 _mm_cmpnlt_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(5)
/// </summary>
- public static Vector128<float> CompareNotLessThanScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static Vector128<float> CompareScalarNotLessThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128 _mm_cmpnle_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(6)
/// </summary>
- public static Vector128<float> CompareNotLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static Vector128<float> CompareScalarNotLessThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128 _mm_cmpord_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(7)
/// </summary>
- public static Vector128<float> CompareOrderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static Vector128<float> CompareScalarOrdered(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128 _mm_cmpunord_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(3)
/// </summary>
- public static Vector128<float> CompareUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
public static Vector128<float> CompareScalarUnordered(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_comieq_ss (__m128 a, __m128 b)
/// COMISS xmm, xmm/m32
/// </summary>
- public static bool CompareEqualOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareEqualOrderedScalar(left, right);
public static bool CompareScalarOrderedEqual(Vector128<float> left, Vector128<float> right) => CompareScalarOrderedEqual(left, right);
/// <summary>
/// int _mm_ucomieq_ss (__m128 a, __m128 b)
/// UCOMISS xmm, xmm/m32
/// </summary>
- public static bool CompareEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareEqualUnorderedScalar(left, right);
public static bool CompareScalarUnorderedEqual(Vector128<float> left, Vector128<float> right) => CompareScalarUnorderedEqual(left, right);
/// <summary>
/// __m128 _mm_cmpeq_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(0)
/// </summary>
- public static Vector128<float> CompareEqualScalar(Vector128<float> left, Vector128<float> right) => CompareEqualScalar(left, right);
public static Vector128<float> CompareScalarEqual(Vector128<float> left, Vector128<float> right) => CompareScalarEqual(left, right);
/// <summary>
/// int _mm_comigt_ss (__m128 a, __m128 b)
/// COMISS xmm, xmm/m32
/// </summary>
- public static bool CompareGreaterThanOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrderedScalar(left, right);
public static bool CompareScalarOrderedGreaterThan(Vector128<float> left, Vector128<float> right) => CompareScalarOrderedGreaterThan(left, right);
/// <summary>
/// int _mm_ucomigt_ss (__m128 a, __m128 b)
/// UCOMISS xmm, xmm/m32
/// </summary>
- public static bool CompareGreaterThanUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareGreaterThanUnorderedScalar(left, right);
public static bool CompareScalarUnorderedGreaterThan(Vector128<float> left, Vector128<float> right) => CompareScalarUnorderedGreaterThan(left, right);
/// <summary>
/// __m128 _mm_cmpgt_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(6)
/// </summary>
- public static Vector128<float> CompareGreaterThanScalar(Vector128<float> left, Vector128<float> right) => CompareGreaterThanScalar(left, right);
public static Vector128<float> CompareScalarGreaterThan(Vector128<float> left, Vector128<float> right) => CompareScalarGreaterThan(left, right);
/// <summary>
/// int _mm_comige_ss (__m128 a, __m128 b)
/// COMISS xmm, xmm/m32
/// </summary>
- public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrEqualOrderedScalar(left, right);
public static bool CompareScalarOrderedGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareScalarOrderedGreaterThanOrEqual(left, right);
/// <summary>
/// int _mm_ucomige_ss (__m128 a, __m128 b)
/// UCOMISS xmm, xmm/m32
/// </summary>
- public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrEqualUnorderedScalar(left, right);
public static bool CompareScalarUnorderedGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareScalarUnorderedGreaterThanOrEqual(left, right);
/// <summary>
/// __m128 _mm_cmpge_ss (__m128 a, __m128 b)
/// CMPPS xmm, xmm/m32, imm8(5)
/// </summary>
- public static Vector128<float> CompareGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrEqualScalar(left, right);
public static Vector128<float> CompareScalarGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareScalarGreaterThanOrEqual(left, right);
/// <summary>
/// int _mm_comilt_ss (__m128 a, __m128 b)
/// COMISS xmm, xmm/m32
/// </summary>
- public static bool CompareLessThanOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareLessThanOrderedScalar(left, right);
public static bool CompareScalarOrderedLessThan(Vector128<float> left, Vector128<float> right) => CompareScalarOrderedLessThan(left, right);
/// <summary>
/// int _mm_ucomilt_ss (__m128 a, __m128 b)
/// UCOMISS xmm, xmm/m32
/// </summary>
- public static bool CompareLessThanUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareLessThanUnorderedScalar(left, right);
public static bool CompareScalarUnorderedLessThan(Vector128<float> left, Vector128<float> right) => CompareScalarUnorderedLessThan(left, right);
/// <summary>
/// __m128 _mm_cmplt_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(1)
/// </summary>
- public static Vector128<float> CompareLessThanScalar(Vector128<float> left, Vector128<float> right) => CompareLessThanScalar(left, right);
public static Vector128<float> CompareScalarLessThan(Vector128<float> left, Vector128<float> right) => CompareScalarLessThan(left, right);
/// <summary>
/// int _mm_comile_ss (__m128 a, __m128 b)
/// COMISS xmm, xmm/m32
/// </summary>
- public static bool CompareLessThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareLessThanOrEqualOrderedScalar(left, right);
public static bool CompareScalarOrderedLessThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareScalarOrderedLessThanOrEqual(left, right);
/// <summary>
/// int _mm_ucomile_ss (__m128 a, __m128 b)
/// UCOMISS xmm, xmm/m32
/// </summary>
- public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareLessThanOrEqualUnorderedScalar(left, right);
public static bool CompareScalarUnorderedLessThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareScalarUnorderedLessThanOrEqual(left, right);
/// <summary>
/// __m128 _mm_cmple_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(2)
/// </summary>
- public static Vector128<float> CompareLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right) => CompareLessThanOrEqualScalar(left, right);
public static Vector128<float> CompareScalarLessThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareScalarLessThanOrEqual(left, right);
/// <summary>
/// int _mm_comineq_ss (__m128 a, __m128 b)
/// COMISS xmm, xmm/m32
/// </summary>
- public static bool CompareNotEqualOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareNotEqualOrderedScalar(left, right);
public static bool CompareScalarOrderedNotEqual(Vector128<float> left, Vector128<float> right) => CompareScalarOrderedNotEqual(left, right);
/// <summary>
/// int _mm_ucomineq_ss (__m128 a, __m128 b)
/// UCOMISS xmm, xmm/m32
/// </summary>
- public static bool CompareNotEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareNotEqualUnorderedScalar(left, right);
public static bool CompareScalarUnorderedNotEqual(Vector128<float> left, Vector128<float> right) => CompareScalarUnorderedNotEqual(left, right);
/// <summary>
/// __m128 _mm_cmpneq_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(4)
/// </summary>
- public static Vector128<float> CompareNotEqualScalar(Vector128<float> left, Vector128<float> right) => CompareNotEqualScalar(left, right);
public static Vector128<float> CompareScalarNotEqual(Vector128<float> left, Vector128<float> right) => CompareScalarNotEqual(left, right);
/// <summary>
/// __m128 _mm_cmpngt_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(2)
/// </summary>
- public static Vector128<float> CompareNotGreaterThanScalar(Vector128<float> left, Vector128<float> right) => CompareNotGreaterThanScalar(left, right);
public static Vector128<float> CompareScalarNotGreaterThan(Vector128<float> left, Vector128<float> right) => CompareScalarNotGreaterThan(left, right);
/// <summary>
/// __m128 _mm_cmpnge_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(1)
/// </summary>
- public static Vector128<float> CompareNotGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right) => CompareNotGreaterThanOrEqualScalar(left, right);
public static Vector128<float> CompareScalarNotGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareScalarNotGreaterThanOrEqual(left, right);
/// <summary>
/// __m128 _mm_cmpnlt_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(5)
/// </summary>
- public static Vector128<float> CompareNotLessThanScalar(Vector128<float> left, Vector128<float> right) => CompareNotLessThanScalar(left, right);
public static Vector128<float> CompareScalarNotLessThan(Vector128<float> left, Vector128<float> right) => CompareScalarNotLessThan(left, right);
/// <summary>
/// __m128 _mm_cmpnle_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(6)
/// </summary>
- public static Vector128<float> CompareNotLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right) => CompareNotLessThanOrEqualScalar(left, right);
public static Vector128<float> CompareScalarNotLessThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareScalarNotLessThanOrEqual(left, right);
/// <summary>
/// __m128 _mm_cmpord_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(7)
/// </summary>
- public static Vector128<float> CompareOrderedScalar(Vector128<float> left, Vector128<float> right) => CompareOrderedScalar(left, right);
public static Vector128<float> CompareScalarOrdered(Vector128<float> left, Vector128<float> right) => CompareScalarOrdered(left, right);
/// <summary>
/// __m128 _mm_cmpunord_ss (__m128 a, __m128 b)
/// CMPSS xmm, xmm/m32, imm8(3)
/// </summary>
- public static Vector128<float> CompareUnorderedScalar(Vector128<float> left, Vector128<float> right) => CompareUnorderedScalar(left, right);
public static Vector128<float> CompareScalarUnordered(Vector128<float> left, Vector128<float> right) => CompareScalarUnordered(left, right);
/// <summary>
/// int _mm_comieq_sd (__m128d a, __m128d b)
/// COMISD xmm, xmm/m64
/// </summary>
- public static bool CompareEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarOrderedEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_ucomieq_sd (__m128d a, __m128d b)
/// UCOMISD xmm, xmm/m64
/// </summary>
- public static bool CompareEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarUnorderedEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128d _mm_cmpeq_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(0)
/// </summary>
- public static Vector128<double> CompareEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static Vector128<double> CompareScalarEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_comigt_sd (__m128d a, __m128d b)
/// COMISD xmm, xmm/m64
/// </summary>
- public static bool CompareGreaterThanOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarOrderedGreaterThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_ucomigt_sd (__m128d a, __m128d b)
/// UCOMISD xmm, xmm/m64
/// </summary>
- public static bool CompareGreaterThanUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarUnorderedGreaterThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128d _mm_cmpgt_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(6)
/// </summary>
- public static Vector128<double> CompareGreaterThanScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static Vector128<double> CompareScalarGreaterThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_comige_sd (__m128d a, __m128d b)
/// COMISD xmm, xmm/m64
/// </summary>
- public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarOrderedGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_ucomige_sd (__m128d a, __m128d b)
/// UCOMISD xmm, xmm/m64
/// </summary>
- public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarUnorderedGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128d _mm_cmpge_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(5)
/// </summary>
- public static Vector128<double> CompareGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static Vector128<double> CompareScalarGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_comilt_sd (__m128d a, __m128d b)
/// COMISD xmm, xmm/m64
/// </summary>
- public static bool CompareLessThanOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarOrderedLessThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_ucomilt_sd (__m128d a, __m128d b)
/// UCOMISD xmm, xmm/m64
/// </summary>
- public static bool CompareLessThanUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarUnorderedLessThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128d _mm_cmplt_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(1)
/// </summary>
- public static Vector128<double> CompareLessThanScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static Vector128<double> CompareScalarLessThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_comile_sd (__m128d a, __m128d b)
/// COMISD xmm, xmm/m64
/// </summary>
- public static bool CompareLessThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarOrderedLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_ucomile_sd (__m128d a, __m128d b)
/// UCOMISD xmm, xmm/m64
/// </summary>
- public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarUnorderedLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128d _mm_cmple_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(2)
/// </summary>
- public static Vector128<double> CompareLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static Vector128<double> CompareScalarLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_comineq_sd (__m128d a, __m128d b)
/// COMISD xmm, xmm/m64
/// </summary>
- public static bool CompareNotEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarOrderedNotEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_ucomineq_sd (__m128d a, __m128d b)
/// UCOMISD xmm, xmm/m64
/// </summary>
- public static bool CompareNotEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static bool CompareScalarUnorderedNotEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128d _mm_cmpneq_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(4)
/// </summary>
- public static Vector128<double> CompareNotEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static Vector128<double> CompareScalarNotEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128d _mm_cmpngt_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(2)
/// </summary>
- public static Vector128<double> CompareNotGreaterThanScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static Vector128<double> CompareScalarNotGreaterThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128d _mm_cmpnge_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(1)
/// </summary>
- public static Vector128<double> CompareNotGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static Vector128<double> CompareScalarNotGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128d _mm_cmpnlt_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(5)
/// </summary>
- public static Vector128<double> CompareNotLessThanScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static Vector128<double> CompareScalarNotLessThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128d _mm_cmpnle_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(6)
/// </summary>
- public static Vector128<double> CompareNotLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static Vector128<double> CompareScalarNotLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128d _mm_cmpord_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(7)
/// </summary>
- public static Vector128<double> CompareOrderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static Vector128<double> CompareScalarOrdered(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// __m128d _mm_cmpunord_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(3)
/// </summary>
- public static Vector128<double> CompareUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
public static Vector128<double> CompareScalarUnordered(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int _mm_comieq_sd (__m128d a, __m128d b)
/// COMISD xmm, xmm/m64
/// </summary>
- public static bool CompareEqualOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareEqualOrderedScalar(left, right);
public static bool CompareScalarOrderedEqual(Vector128<double> left, Vector128<double> right) => CompareScalarOrderedEqual(left, right);
/// <summary>
/// int _mm_ucomieq_sd (__m128d a, __m128d b)
/// UCOMISD xmm, xmm/m64
/// </summary>
- public static bool CompareEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareEqualUnorderedScalar(left, right);
public static bool CompareScalarUnorderedEqual(Vector128<double> left, Vector128<double> right) => CompareScalarUnorderedEqual(left, right);
/// <summary>
/// __m128d _mm_cmpeq_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(0)
/// </summary>
- public static Vector128<double> CompareEqualScalar(Vector128<double> left, Vector128<double> right) => CompareEqualScalar(left, right);
public static Vector128<double> CompareScalarEqual(Vector128<double> left, Vector128<double> right) => CompareScalarEqual(left, right);
/// <summary>
/// int _mm_comigt_sd (__m128d a, __m128d b)
/// COMISD xmm, xmm/m64
/// </summary>
- public static bool CompareGreaterThanOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrderedScalar(left, right);
public static bool CompareScalarOrderedGreaterThan(Vector128<double> left, Vector128<double> right) => CompareScalarOrderedGreaterThan(left, right);
/// <summary>
/// int _mm_ucomigt_sd (__m128d a, __m128d b)
/// UCOMISD xmm, xmm/m64
/// </summary>
- public static bool CompareGreaterThanUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareGreaterThanUnorderedScalar(left, right);
public static bool CompareScalarUnorderedGreaterThan(Vector128<double> left, Vector128<double> right) => CompareScalarUnorderedGreaterThan(left, right);
/// <summary>
/// __m128d _mm_cmpgt_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(6)
/// </summary>
- public static Vector128<double> CompareGreaterThanScalar(Vector128<double> left, Vector128<double> right) => CompareGreaterThanScalar(left, right);
public static Vector128<double> CompareScalarGreaterThan(Vector128<double> left, Vector128<double> right) => CompareScalarGreaterThan(left, right);
/// <summary>
/// int _mm_comige_sd (__m128d a, __m128d b)
/// COMISD xmm, xmm/m64
/// </summary>
- public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrEqualOrderedScalar(left, right);
public static bool CompareScalarOrderedGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareScalarOrderedGreaterThanOrEqual(left, right);
/// <summary>
/// int _mm_ucomige_sd (__m128d a, __m128d b)
/// UCOMISD xmm, xmm/m64
/// </summary>
- public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrEqualUnorderedScalar(left, right);
public static bool CompareScalarUnorderedGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareScalarUnorderedGreaterThanOrEqual(left, right);
/// <summary>
/// __m128d _mm_cmpge_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(5)
/// </summary>
- public static Vector128<double> CompareGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrEqualScalar(left, right);
public static Vector128<double> CompareScalarGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareScalarGreaterThanOrEqual(left, right);
/// <summary>
/// int _mm_comilt_sd (__m128d a, __m128d b)
/// COMISD xmm, xmm/m64
/// </summary>
- public static bool CompareLessThanOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareLessThanOrderedScalar(left, right);
public static bool CompareScalarOrderedLessThan(Vector128<double> left, Vector128<double> right) => CompareScalarOrderedLessThan(left, right);
/// <summary>
/// int _mm_ucomilt_sd (__m128d a, __m128d b)
/// UCOMISD xmm, xmm/m64
/// </summary>
- public static bool CompareLessThanUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareLessThanUnorderedScalar(left, right);
public static bool CompareScalarUnorderedLessThan(Vector128<double> left, Vector128<double> right) => CompareScalarUnorderedLessThan(left, right);
/// <summary>
/// __m128d _mm_cmplt_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(1)
/// </summary>
- public static Vector128<double> CompareLessThanScalar(Vector128<double> left, Vector128<double> right) => CompareLessThanScalar(left, right);
public static Vector128<double> CompareScalarLessThan(Vector128<double> left, Vector128<double> right) => CompareScalarLessThan(left, right);
/// <summary>
/// int _mm_comile_sd (__m128d a, __m128d b)
/// COMISD xmm, xmm/m64
/// </summary>
- public static bool CompareLessThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareLessThanOrEqualOrderedScalar(left, right);
public static bool CompareScalarOrderedLessThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareScalarOrderedLessThanOrEqual(left, right);
/// <summary>
/// int _mm_ucomile_sd (__m128d a, __m128d b)
/// UCOMISD xmm, xmm/m64
/// </summary>
- public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareLessThanOrEqualUnorderedScalar(left, right);
public static bool CompareScalarUnorderedLessThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareScalarUnorderedLessThanOrEqual(left, right);
/// <summary>
/// __m128d _mm_cmple_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(2)
/// </summary>
- public static Vector128<double> CompareLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) => CompareLessThanOrEqualScalar(left, right);
public static Vector128<double> CompareScalarLessThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareScalarLessThanOrEqual(left, right);
/// <summary>
/// int _mm_comineq_sd (__m128d a, __m128d b)
/// COMISD xmm, xmm/m64
/// </summary>
- public static bool CompareNotEqualOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareNotEqualOrderedScalar(left, right);
public static bool CompareScalarOrderedNotEqual(Vector128<double> left, Vector128<double> right) => CompareScalarOrderedNotEqual(left, right);
/// <summary>
/// int _mm_ucomineq_sd (__m128d a, __m128d b)
/// UCOMISD xmm, xmm/m64
/// </summary>
- public static bool CompareNotEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareNotEqualUnorderedScalar(left, right);
public static bool CompareScalarUnorderedNotEqual(Vector128<double> left, Vector128<double> right) => CompareScalarUnorderedNotEqual(left, right);
/// <summary>
/// __m128d _mm_cmpneq_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(4)
/// </summary>
- public static Vector128<double> CompareNotEqualScalar(Vector128<double> left, Vector128<double> right) => CompareNotEqualScalar(left, right);
public static Vector128<double> CompareScalarNotEqual(Vector128<double> left, Vector128<double> right) => CompareScalarNotEqual(left, right);
/// <summary>
/// __m128d _mm_cmpngt_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(2)
/// </summary>
- public static Vector128<double> CompareNotGreaterThanScalar(Vector128<double> left, Vector128<double> right) => CompareNotGreaterThanScalar(left, right);
public static Vector128<double> CompareScalarNotGreaterThan(Vector128<double> left, Vector128<double> right) => CompareScalarNotGreaterThan(left, right);
/// <summary>
/// __m128d _mm_cmpnge_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(1)
/// </summary>
- public static Vector128<double> CompareNotGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) => CompareNotGreaterThanOrEqualScalar(left, right);
public static Vector128<double> CompareScalarNotGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareScalarNotGreaterThanOrEqual(left, right);
/// <summary>
/// __m128d _mm_cmpnlt_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(5)
/// </summary>
- public static Vector128<double> CompareNotLessThanScalar(Vector128<double> left, Vector128<double> right) => CompareNotLessThanScalar(left, right);
public static Vector128<double> CompareScalarNotLessThan(Vector128<double> left, Vector128<double> right) => CompareScalarNotLessThan(left, right);
/// <summary>
/// __m128d _mm_cmpnle_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(6)
/// </summary>
- public static Vector128<double> CompareNotLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) => CompareNotLessThanOrEqualScalar(left, right);
public static Vector128<double> CompareScalarNotLessThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareScalarNotLessThanOrEqual(left, right);
/// <summary>
/// __m128d _mm_cmpord_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(7)
/// </summary>
- public static Vector128<double> CompareOrderedScalar(Vector128<double> left, Vector128<double> right) => CompareOrderedScalar(left, right);
public static Vector128<double> CompareScalarOrdered(Vector128<double> left, Vector128<double> right) => CompareScalarOrdered(left, right);
/// <summary>
/// __m128d _mm_cmpunord_sd (__m128d a, __m128d b)
/// CMPSD xmm, xmm/m64, imm8(3)
/// </summary>
- public static Vector128<double> CompareUnorderedScalar(Vector128<double> left, Vector128<double> right) => CompareUnorderedScalar(left, right);
public static Vector128<double> CompareScalarUnordered(Vector128<double> left, Vector128<double> right) => CompareScalarUnordered(left, right);
/// <summary>
if (op2 != nullptr)
{
- // The Compare*OrderedScalar and Compare*UnorderedScalar intrinsics come down this
+ // The CompareScalarOrdered* and CompareScalarUnordered* intrinsics come down this
// code path. They are all MultiIns, as the return value comes from the flags and
// we have two operands instead.
switch (intrinsicId)
{
- case NI_SSE_CompareEqualOrderedScalar:
- case NI_SSE_CompareEqualUnorderedScalar:
+ case NI_SSE_CompareScalarOrderedEqual:
+ case NI_SSE_CompareScalarUnorderedEqual:
{
assert(baseType == TYP_FLOAT);
regNumber tmpReg = node->GetSingleTempReg();
break;
}
- case NI_SSE_CompareGreaterThanOrderedScalar:
- case NI_SSE_CompareGreaterThanUnorderedScalar:
+ case NI_SSE_CompareScalarOrderedGreaterThan:
+ case NI_SSE_CompareScalarUnorderedGreaterThan:
{
assert(baseType == TYP_FLOAT);
instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, node->gtSIMDBaseType);
break;
}
- case NI_SSE_CompareGreaterThanOrEqualOrderedScalar:
- case NI_SSE_CompareGreaterThanOrEqualUnorderedScalar:
+ case NI_SSE_CompareScalarOrderedGreaterThanOrEqual:
+ case NI_SSE_CompareScalarUnorderedGreaterThanOrEqual:
{
assert(baseType == TYP_FLOAT);
instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, node->gtSIMDBaseType);
break;
}
- case NI_SSE_CompareLessThanOrderedScalar:
- case NI_SSE_CompareLessThanUnorderedScalar:
+ case NI_SSE_CompareScalarOrderedLessThan:
+ case NI_SSE_CompareScalarUnorderedLessThan:
{
assert(baseType == TYP_FLOAT);
instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, node->gtSIMDBaseType);
break;
}
- case NI_SSE_CompareLessThanOrEqualOrderedScalar:
- case NI_SSE_CompareLessThanOrEqualUnorderedScalar:
+ case NI_SSE_CompareScalarOrderedLessThanOrEqual:
+ case NI_SSE_CompareScalarUnorderedLessThanOrEqual:
{
assert(baseType == TYP_FLOAT);
instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, node->gtSIMDBaseType);
break;
}
- case NI_SSE_CompareNotEqualOrderedScalar:
- case NI_SSE_CompareNotEqualUnorderedScalar:
+ case NI_SSE_CompareScalarOrderedNotEqual:
+ case NI_SSE_CompareScalarUnorderedNotEqual:
{
assert(baseType == TYP_FLOAT);
regNumber tmpReg = node->GetSingleTempReg();
break;
}
- case NI_SSE2_CompareEqualOrderedScalar:
- case NI_SSE2_CompareEqualUnorderedScalar:
+ case NI_SSE2_CompareScalarOrderedEqual:
+ case NI_SSE2_CompareScalarUnorderedEqual:
{
assert(baseType == TYP_DOUBLE);
regNumber tmpReg = node->GetSingleTempReg();
break;
}
- case NI_SSE2_CompareGreaterThanOrderedScalar:
- case NI_SSE2_CompareGreaterThanUnorderedScalar:
+ case NI_SSE2_CompareScalarOrderedGreaterThan:
+ case NI_SSE2_CompareScalarUnorderedGreaterThan:
{
assert(baseType == TYP_DOUBLE);
instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, baseType);
break;
}
- case NI_SSE2_CompareGreaterThanOrEqualOrderedScalar:
- case NI_SSE2_CompareGreaterThanOrEqualUnorderedScalar:
+ case NI_SSE2_CompareScalarOrderedGreaterThanOrEqual:
+ case NI_SSE2_CompareScalarUnorderedGreaterThanOrEqual:
{
assert(baseType == TYP_DOUBLE);
instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, baseType);
break;
}
- case NI_SSE2_CompareLessThanOrderedScalar:
- case NI_SSE2_CompareLessThanUnorderedScalar:
+ case NI_SSE2_CompareScalarOrderedLessThan:
+ case NI_SSE2_CompareScalarUnorderedLessThan:
{
assert(baseType == TYP_DOUBLE);
instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, baseType);
break;
}
- case NI_SSE2_CompareLessThanOrEqualOrderedScalar:
- case NI_SSE2_CompareLessThanOrEqualUnorderedScalar:
+ case NI_SSE2_CompareScalarOrderedLessThanOrEqual:
+ case NI_SSE2_CompareScalarUnorderedLessThanOrEqual:
{
assert(baseType == TYP_DOUBLE);
instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, baseType);
break;
}
- case NI_SSE2_CompareNotEqualOrderedScalar:
- case NI_SSE2_CompareNotEqualUnorderedScalar:
+ case NI_SSE2_CompareScalarOrderedNotEqual:
+ case NI_SSE2_CompareScalarUnorderedNotEqual:
{
assert(baseType == TYP_DOUBLE);
instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, baseType);
HARDWARE_INTRINSIC(SSE_And, "And", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_andps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
HARDWARE_INTRINSIC(SSE_AndNot, "AndNot", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_andnps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
HARDWARE_INTRINSIC(SSE_CompareEqual, "CompareEqual", SSE, 0, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
-HARDWARE_INTRINSIC(SSE_CompareEqualOrderedScalar, "CompareEqualOrderedScalar", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(SSE_CompareEqualScalar, "CompareEqualScalar", SSE, 0, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
-HARDWARE_INTRINSIC(SSE_CompareEqualUnorderedScalar, "CompareEqualUnorderedScalar", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE_CompareScalarOrderedEqual, "CompareScalarOrderedEqual", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE_CompareScalarEqual, "CompareScalarEqual", SSE, 0, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE_CompareScalarUnorderedEqual, "CompareScalarUnorderedEqual", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE_CompareGreaterThan, "CompareGreaterThan", SSE, 6, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE_CompareGreaterThanOrderedScalar, "CompareGreaterThanOrderedScalar", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(SSE_CompareGreaterThanScalar, "CompareGreaterThanScalar", SSE, 6, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
-HARDWARE_INTRINSIC(SSE_CompareGreaterThanUnorderedScalar, "CompareGreaterThanUnorderedScalar", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE_CompareScalarOrderedGreaterThan, "CompareScalarOrderedGreaterThan", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE_CompareScalarGreaterThan, "CompareScalarGreaterThan", SSE, 6, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE_CompareScalarUnorderedGreaterThan, "CompareScalarUnorderedGreaterThan", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE_CompareGreaterThanOrEqual, "CompareGreaterThanOrEqual", SSE, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE_CompareGreaterThanOrEqualOrderedScalar, "CompareGreaterThanOrEqualOrderedScalar", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(SSE_CompareGreaterThanOrEqualScalar, "CompareGreaterThanOrEqualScalar", SSE, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
-HARDWARE_INTRINSIC(SSE_CompareGreaterThanOrEqualUnorderedScalar, "CompareGreaterThanOrEqualUnorderedScalar", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE_CompareScalarOrderedGreaterThanOrEqual, "CompareScalarOrderedGreaterThanOrEqual", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE_CompareScalarGreaterThanOrEqual, "CompareScalarGreaterThanOrEqual", SSE, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE_CompareScalarUnorderedGreaterThanOrEqual, "CompareScalarUnorderedGreaterThanOrEqual", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE_CompareLessThan, "CompareLessThan", SSE, 1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE_CompareLessThanOrderedScalar, "CompareLessThanOrderedScalar", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(SSE_CompareLessThanScalar, "CompareLessThanScalar", SSE, 1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
-HARDWARE_INTRINSIC(SSE_CompareLessThanUnorderedScalar, "CompareLessThanUnorderedScalar", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE_CompareScalarOrderedLessThan, "CompareScalarOrderedLessThan", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE_CompareScalarLessThan, "CompareScalarLessThan", SSE, 1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE_CompareScalarUnorderedLessThan, "CompareScalarUnorderedLessThan", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE_CompareLessThanOrEqual, "CompareLessThanOrEqual", SSE, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE_CompareLessThanOrEqualOrderedScalar, "CompareLessThanOrEqualOrderedScalar", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(SSE_CompareLessThanOrEqualScalar, "CompareLessThanOrEqualScalar", SSE, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
-HARDWARE_INTRINSIC(SSE_CompareLessThanOrEqualUnorderedScalar, "CompareLessThanOrEqualUnorderedScalar", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE_CompareScalarOrderedLessThanOrEqual, "CompareScalarOrderedLessThanOrEqual", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE_CompareScalarLessThanOrEqual, "CompareScalarLessThanOrEqual", SSE, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE_CompareScalarUnorderedLessThanOrEqual, "CompareScalarUnorderedLessThanOrEqual", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE_CompareNotEqual, "CompareNotEqual", SSE, 4, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
-HARDWARE_INTRINSIC(SSE_CompareNotEqualOrderedScalar, "CompareNotEqualOrderedScalar", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(SSE_CompareNotEqualScalar, "CompareNotEqualScalar", SSE, 4, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
-HARDWARE_INTRINSIC(SSE_CompareNotEqualUnorderedScalar, "CompareNotEqualUnorderedScalar", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE_CompareScalarOrderedNotEqual, "CompareScalarOrderedNotEqual", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE_CompareScalarNotEqual, "CompareScalarNotEqual", SSE, 4, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE_CompareScalarUnorderedNotEqual, "CompareScalarUnorderedNotEqual", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomiss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE_CompareNotGreaterThan, "CompareNotGreaterThan", SSE, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE_CompareNotGreaterThanScalar, "CompareNotGreaterThanScalar", SSE, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE_CompareScalarNotGreaterThan, "CompareScalarNotGreaterThan", SSE, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE_CompareNotGreaterThanOrEqual, "CompareNotGreaterThanOrEqual", SSE, 1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE_CompareNotGreaterThanOrEqualScalar, "CompareNotGreaterThanOrEqualScalar", SSE, 1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE_CompareScalarNotGreaterThanOrEqual, "CompareScalarNotGreaterThanOrEqual", SSE, 1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE_CompareNotLessThan, "CompareNotLessThan", SSE, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE_CompareNotLessThanScalar, "CompareNotLessThanScalar", SSE, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE_CompareScalarNotLessThan, "CompareScalarNotLessThan", SSE, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE_CompareNotLessThanOrEqual, "CompareNotLessThanOrEqual", SSE, 6, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE_CompareNotLessThanOrEqualScalar, "CompareNotLessThanOrEqualScalar", SSE, 6, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE_CompareScalarNotLessThanOrEqual, "CompareScalarNotLessThanOrEqual", SSE, 6, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE_CompareOrdered, "CompareOrdered", SSE, 7, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE_CompareOrderedScalar, "CompareOrderedScalar", SSE, 7, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE_CompareScalarOrdered, "CompareScalarOrdered", SSE, 7, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE_CompareUnordered, "CompareUnordered", SSE, 3, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpps, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE_CompareUnorderedScalar, "CompareUnorderedScalar", SSE, 3, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE_CompareScalarUnordered, "CompareScalarUnordered", SSE, 3, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpss, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE_ConvertToInt32, "ConvertToInt32", SSE, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvtss2si, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE_ConvertScalarToVector128Single, "ConvertScalarToVector128Single", SSE, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvtsi2ss, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromSecondArg|HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE_ConvertToInt32WithTruncation, "ConvertToInt32WithTruncation", SSE, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvttss2si, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE2_AndNot, "AndNot", SSE2, -1, 16, 2, {INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_invalid, INS_andnpd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
HARDWARE_INTRINSIC(SSE2_Average, "Average", SSE2, -1, 16, 2, {INS_invalid, INS_pavgb, INS_invalid, INS_pavgw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
HARDWARE_INTRINSIC(SSE2_CompareEqual, "CompareEqual", SSE2, 0, 16, 2, {INS_pcmpeqb, INS_pcmpeqb, INS_pcmpeqw, INS_pcmpeqw, INS_pcmpeqd, INS_pcmpeqd, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
-HARDWARE_INTRINSIC(SSE2_CompareEqualOrderedScalar, "CompareEqualOrderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(SSE2_CompareEqualScalar, "CompareEqualScalar", SSE2, 0, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
-HARDWARE_INTRINSIC(SSE2_CompareEqualUnorderedScalar, "CompareEqualUnorderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE2_CompareScalarOrderedEqual, "CompareScalarOrderedEqual", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE2_CompareScalarEqual, "CompareScalarEqual", SSE2, 0, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE2_CompareScalarUnorderedEqual, "CompareScalarUnorderedEqual", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE2_CompareGreaterThan, "CompareGreaterThan", SSE2, 6, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE2_CompareGreaterThanOrderedScalar, "CompareGreaterThanOrderedScalar", SSE2, -1, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(SSE2_CompareGreaterThanScalar, "CompareGreaterThanScalar", SSE2, 6, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
-HARDWARE_INTRINSIC(SSE2_CompareGreaterThanUnorderedScalar, "CompareGreaterThanUnorderedScalar", SSE2, -1, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE2_CompareScalarOrderedGreaterThan, "CompareScalarOrderedGreaterThan", SSE2, -1, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE2_CompareScalarGreaterThan, "CompareScalarGreaterThan", SSE2, 6, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE2_CompareScalarUnorderedGreaterThan, "CompareScalarUnorderedGreaterThan", SSE2, -1, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE2_CompareGreaterThanOrEqual, "CompareGreaterThanOrEqual", SSE2, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE2_CompareGreaterThanOrEqualOrderedScalar, "CompareGreaterThanOrEqualOrderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(SSE2_CompareGreaterThanOrEqualScalar, "CompareGreaterThanOrEqualScalar", SSE2, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
-HARDWARE_INTRINSIC(SSE2_CompareGreaterThanOrEqualUnorderedScalar, "CompareGreaterThanOrEqualUnorderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE2_CompareScalarOrderedGreaterThanOrEqual, "CompareScalarOrderedGreaterThanOrEqual", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE2_CompareScalarGreaterThanOrEqual, "CompareScalarGreaterThanOrEqual", SSE2, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE2_CompareScalarUnorderedGreaterThanOrEqual, "CompareScalarUnorderedGreaterThanOrEqual", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE2_CompareLessThan, "CompareLessThan", SSE2, 1, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_Special, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE2_CompareLessThanOrderedScalar, "CompareLessThanOrderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(SSE2_CompareLessThanScalar, "CompareLessThanScalar", SSE2, 1, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
-HARDWARE_INTRINSIC(SSE2_CompareLessThanUnorderedScalar, "CompareLessThanUnorderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE2_CompareScalarOrderedLessThan, "CompareScalarOrderedLessThan", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE2_CompareScalarLessThan, "CompareScalarLessThan", SSE2, 1, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE2_CompareScalarUnorderedLessThan, "CompareScalarUnorderedLessThan", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE2_CompareLessThanOrEqual, "CompareLessThanOrEqual", SSE2, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE2_CompareLessThanOrEqualOrderedScalar, "CompareLessThanOrEqualOrderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(SSE2_CompareLessThanOrEqualScalar, "CompareLessThanOrEqualScalar", SSE2, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
-HARDWARE_INTRINSIC(SSE2_CompareLessThanOrEqualUnorderedScalar, "CompareLessThanOrEqualUnorderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE2_CompareScalarOrderedLessThanOrEqual, "CompareScalarOrderedLessThanOrEqual", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE2_CompareScalarLessThanOrEqual, "CompareScalarLessThanOrEqual", SSE2, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE2_CompareScalarUnorderedLessThanOrEqual, "CompareScalarUnorderedLessThanOrEqual", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE2_CompareNotEqual, "CompareNotEqual", SSE2, 4, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
-HARDWARE_INTRINSIC(SSE2_CompareNotEqualOrderedScalar, "CompareNotEqualOrderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(SSE2_CompareNotEqualScalar, "CompareNotEqualScalar", SSE2, 4, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
-HARDWARE_INTRINSIC(SSE2_CompareNotEqualUnorderedScalar, "CompareNotEqualUnorderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE2_CompareScalarOrderedNotEqual, "CompareScalarOrderedNotEqual", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(SSE2_CompareScalarNotEqual, "CompareScalarNotEqual", SSE2, 4, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE2_CompareScalarUnorderedNotEqual, "CompareScalarUnorderedNotEqual", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_Commutative|HW_Flag_MultiIns|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE2_CompareNotGreaterThan, "CompareNotGreaterThan", SSE2, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE2_CompareNotGreaterThanScalar, "CompareNotGreaterThanScalar", SSE2, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE2_CompareScalarNotGreaterThan, "CompareScalarNotGreaterThan", SSE2, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE2_CompareNotGreaterThanOrEqual, "CompareNotGreaterThanOrEqual", SSE2, 1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE2_CompareNotGreaterThanOrEqualScalar, "CompareNotGreaterThanOrEqualScalar", SSE2, 1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE2_CompareScalarNotGreaterThanOrEqual, "CompareScalarNotGreaterThanOrEqual", SSE2, 1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE2_CompareNotLessThan, "CompareNotLessThan", SSE2, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE2_CompareNotLessThanScalar, "CompareNotLessThanScalar", SSE2, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE2_CompareScalarNotLessThan, "CompareScalarNotLessThan", SSE2, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE2_CompareNotLessThanOrEqual, "CompareNotLessThanOrEqual", SSE2, 6, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE2_CompareNotLessThanOrEqualScalar, "CompareNotLessThanOrEqualScalar", SSE2, 6, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE2_CompareScalarNotLessThanOrEqual, "CompareScalarNotLessThanOrEqual", SSE2, 6, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE2_CompareOrdered, "CompareOrdered", SSE2, 7, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE2_CompareOrderedScalar, "CompareOrderedScalar", SSE2, 7, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE2_CompareScalarOrdered, "CompareScalarOrdered", SSE2, 7, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE2_CompareUnordered, "CompareUnordered", SSE2, 3, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(SSE2_CompareUnorderedScalar, "CompareUnorderedScalar", SSE2, 3, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
+HARDWARE_INTRINSIC(SSE2_CompareScalarUnordered, "CompareScalarUnordered", SSE2, 3, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits)
HARDWARE_INTRINSIC(SSE2_ConvertToInt32, "ConvertToInt32", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_xmm2i, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvtsd2si}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE2_ConvertToInt32WithTruncation, "ConvertToInt32WithTruncation", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvttsd2si}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(SSE2_ConvertToUInt32, "ConvertToUInt32", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_xmm2i, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(AVX2_ExtractVector128, "ExtractVector128", AVX2, -1, 32, 2, {INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_invalid, INS_invalid}, HW_Category_IMM, HW_Flag_FullRangeIMM)
HARDWARE_INTRINSIC(AVX2_ConvertToInt32, "ConvertToInt32", AVX2, -1, 32, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_xmm2i, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(AVX2_ConvertToUInt32, "ConvertToUInt32", AVX2, -1, 32, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_xmm2i, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_NoRMWSemantics)
-HARDWARE_INTRINSIC(AVX2_ConvertToVector256Int16, "ConvertToVector256Int16", AVX2, -1, 32, 1, {INS_pmovsxbw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg)
-HARDWARE_INTRINSIC(AVX2_ConvertToVector256UInt16, "ConvertToVector256UInt16", AVX2, -1, 32, 1, {INS_invalid, INS_pmovzxbw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg)
-HARDWARE_INTRINSIC(AVX2_ConvertToVector256Int32, "ConvertToVector256Int32", AVX2, -1, 32, 1, {INS_pmovsxbd, INS_invalid, INS_pmovsxwd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg)
-HARDWARE_INTRINSIC(AVX2_ConvertToVector256UInt32, "ConvertToVector256UInt32", AVX2, -1, 32, 1, {INS_invalid, INS_pmovzxbd, INS_invalid, INS_pmovzxwd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg)
-HARDWARE_INTRINSIC(AVX2_ConvertToVector256Int64, "ConvertToVector256Int64", AVX2, -1, 32, 1, {INS_pmovsxbq, INS_invalid, INS_pmovsxwq, INS_invalid, INS_pmovsxdq, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg)
-HARDWARE_INTRINSIC(AVX2_ConvertToVector256UInt64, "ConvertToVector256UInt64", AVX2, -1, 32, 1, {INS_invalid, INS_pmovzxbq, INS_invalid, INS_pmovzxwq, INS_invalid, INS_pmovzxdq, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(AVX2_ConvertToVector256Int16, "ConvertToVector256Int16", AVX2, -1, 32, 1, {INS_pmovsxbw, INS_pmovzxbw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(AVX2_ConvertToVector256Int32, "ConvertToVector256Int32", AVX2, -1, 32, 1, {INS_pmovsxbd, INS_pmovzxbd, INS_pmovsxwd, INS_pmovzxwd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(AVX2_ConvertToVector256Int64, "ConvertToVector256Int64", AVX2, -1, 32, 1, {INS_pmovsxbq, INS_pmovzxbq, INS_pmovsxwq, INS_pmovzxwq, INS_pmovsxdq, INS_pmovzxdq, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg)
HARDWARE_INTRINSIC(AVX2_GatherVector128, "GatherVector128", AVX2, -1, 16, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpgatherdd, INS_vpgatherdd, INS_vpgatherdq, INS_vpgatherdq, INS_vgatherdps, INS_vgatherdpd}, HW_Category_IMM, HW_Flag_SpecialCodeGen|HW_Flag_NoContainment)
HARDWARE_INTRINSIC(AVX2_GatherVector256, "GatherVector256", AVX2, -1, 32, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpgatherdd, INS_vpgatherdd, INS_vpgatherdq, INS_vpgatherdq, INS_vgatherdps, INS_vgatherdpd}, HW_Category_IMM, HW_Flag_MaybeMemoryLoad|HW_Flag_SpecialCodeGen|HW_Flag_NoContainment)
HARDWARE_INTRINSIC(AVX2_GatherMaskVector128, "GatherMaskVector128", AVX2, -1, 16, 5, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpgatherdd, INS_vpgatherdd, INS_vpgatherdq, INS_vpgatherdq, INS_vgatherdps, INS_vgatherdpd}, HW_Category_IMM, HW_Flag_MaybeMemoryLoad|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_NoContainment)
{
switch (intrinsicId)
{
- case NI_SSE_CompareLessThanOrderedScalar:
- case NI_SSE_CompareLessThanUnorderedScalar:
- case NI_SSE_CompareLessThanOrEqualOrderedScalar:
- case NI_SSE_CompareLessThanOrEqualUnorderedScalar:
- case NI_SSE2_CompareLessThanOrderedScalar:
- case NI_SSE2_CompareLessThanUnorderedScalar:
- case NI_SSE2_CompareLessThanOrEqualOrderedScalar:
- case NI_SSE2_CompareLessThanOrEqualUnorderedScalar:
+ case NI_SSE_CompareScalarOrderedLessThan:
+ case NI_SSE_CompareScalarUnorderedLessThan:
+ case NI_SSE_CompareScalarOrderedLessThanOrEqual:
+ case NI_SSE_CompareScalarUnorderedLessThanOrEqual:
+ case NI_SSE2_CompareScalarOrderedLessThan:
+ case NI_SSE2_CompareScalarUnorderedLessThan:
+ case NI_SSE2_CompareScalarOrderedLessThanOrEqual:
+ case NI_SSE2_CompareScalarUnorderedLessThanOrEqual:
{
// We need to swap the operands for CompareLessThanOrEqual
node->gtOp1 = op2;
default:
{
- // TODO-XArch-CQ: The Compare*OrderedScalar and Compare*UnorderedScalar methods
+ // TODO-XArch-CQ: The CompareScalarOrdered* and CompareScalarUnordered* methods
// are commutative if you also inverse the intrinsic.
break;
}
break;
}
- case NI_SSE_CompareEqualOrderedScalar:
- case NI_SSE_CompareEqualUnorderedScalar:
- case NI_SSE_CompareNotEqualOrderedScalar:
- case NI_SSE_CompareNotEqualUnorderedScalar:
- case NI_SSE2_CompareEqualOrderedScalar:
- case NI_SSE2_CompareEqualUnorderedScalar:
- case NI_SSE2_CompareNotEqualOrderedScalar:
- case NI_SSE2_CompareNotEqualUnorderedScalar:
+ case NI_SSE_CompareScalarOrderedEqual:
+ case NI_SSE_CompareScalarUnorderedEqual:
+ case NI_SSE_CompareScalarOrderedNotEqual:
+ case NI_SSE_CompareScalarUnorderedNotEqual:
+ case NI_SSE2_CompareScalarOrderedEqual:
+ case NI_SSE2_CompareScalarUnorderedEqual:
+ case NI_SSE2_CompareScalarOrderedNotEqual:
+ case NI_SSE2_CompareScalarUnorderedNotEqual:
{
buildInternalIntRegisterDefForNode(intrinsicTree, allByteRegs());
setInternalRegsDelayFree = true;
var vf1 = Unsafe.Read<Vector256<float>>(floatTable.inArray1Ptr);
var vf2 = Unsafe.Read<Vector256<float>>(floatTable.inArray2Ptr);
- var vf3 = Avx.Compare(vf1, vf2, FloatComparisonMode.EqualOrderedNonSignaling);
+ var vf3 = Avx.Compare(vf1, vf2, FloatComparisonMode.OrderedEqualNonSignaling);
Unsafe.Write(floatTable.outArrayPtr, vf3);
var vd1 = Unsafe.Read<Vector256<double>>(doubleTable.inArray1Ptr);
var vd2 = Unsafe.Read<Vector256<double>>(doubleTable.inArray2Ptr);
- var vd3 = Avx.Compare(vd1, vd2, FloatComparisonMode.EqualOrderedNonSignaling);
+ var vd3 = Avx.Compare(vd1, vd2, FloatComparisonMode.OrderedEqualNonSignaling);
Unsafe.Write(doubleTable.outArrayPtr, vd3);
for (int i = 0; i < floatTable.outArray.Length; i++)
var svf1 = Unsafe.Read<Vector128<float>>(floatTable.inArray1Ptr);
var svf2 = Unsafe.Read<Vector128<float>>(floatTable.inArray2Ptr);
- var svf3 = Avx.Compare(svf1, svf2, FloatComparisonMode.EqualOrderedNonSignaling);
+ var svf3 = Avx.Compare(svf1, svf2, FloatComparisonMode.OrderedEqualNonSignaling);
Unsafe.Write(floatTable.outArrayPtr, svf3);
var svd1 = Unsafe.Read<Vector128<double>>(doubleTable.inArray1Ptr);
var svd2 = Unsafe.Read<Vector128<double>>(doubleTable.inArray2Ptr);
- var svd3 = Avx.Compare(svd1, svd2, FloatComparisonMode.EqualOrderedNonSignaling);
+ var svd3 = Avx.Compare(svd1, svd2, FloatComparisonMode.OrderedEqualNonSignaling);
Unsafe.Write(doubleTable.outArrayPtr, svd3);
for (int i = 0; i < floatTable.outArray.Length/2; i++)
var vf1 = Unsafe.Read<Vector128<float>>(floatTable.inArray1Ptr);
var vf2 = Unsafe.Read<Vector128<float>>(floatTable.inArray2Ptr);
- var vf3 = Avx.CompareScalar(vf1, vf2, FloatComparisonMode.EqualOrderedNonSignaling);
+ var vf3 = Avx.CompareScalar(vf1, vf2, FloatComparisonMode.OrderedEqualNonSignaling);
Unsafe.Write(floatTable.outArrayPtr, vf3);
var vd1 = Unsafe.Read<Vector128<double>>(doubleTable.inArray1Ptr);
var vd2 = Unsafe.Read<Vector128<double>>(doubleTable.inArray2Ptr);
- var vd3 = Avx.CompareScalar(vd1, vd2, FloatComparisonMode.EqualOrderedNonSignaling);
+ var vd3 = Avx.CompareScalar(vd1, vd2, FloatComparisonMode.OrderedEqualNonSignaling);
Unsafe.Write(doubleTable.outArrayPtr, vd3);
{
public static partial class Program
{
- private static void ConvertToVector256UInt16Byte()
+ private static void ConvertToVector256Int16Byte()
{
- var test = new SimpleUnaryOpTest__ConvertToVector256UInt16Byte();
+ var test = new SimpleUnaryOpTest__ConvertToVector256Int16Byte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleUnaryOpTest__ConvertToVector256UInt16Byte
+ public sealed unsafe class SimpleUnaryOpTest__ConvertToVector256Int16Byte
{
private const int VectorSize = 32;
private SimpleUnaryOpTest__DataTable<UInt16, Byte> _dataTable;
- static SimpleUnaryOpTest__ConvertToVector256UInt16Byte()
+ static SimpleUnaryOpTest__ConvertToVector256Int16Byte()
{
var random = new Random();
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Byte>, byte>(ref _clsVar), ref Unsafe.As<Byte, byte>(ref _data[0]), 16);
}
- public SimpleUnaryOpTest__ConvertToVector256UInt16Byte()
+ public SimpleUnaryOpTest__ConvertToVector256Int16Byte()
{
Succeeded = true;
public void RunBasicScenario_UnsafeRead()
{
- var result = Avx2.ConvertToVector256UInt16(
+ var result = Avx2.ConvertToVector256Int16(
Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr)
);
public void RunBasicScenario_Load()
{
- var result = Avx2.ConvertToVector256UInt16(
+ var result = Avx2.ConvertToVector256Int16(
Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr))
);
public void RunBasicScenario_LoadAligned()
{
- var result = Avx2.ConvertToVector256UInt16(
+ var result = Avx2.ConvertToVector256Int16(
Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr))
);
public void RunReflectionScenario_UnsafeRead()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt16), new Type[] { typeof(Vector128<Byte>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int16), new Type[] { typeof(Vector128<Byte>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr)
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt16>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int16>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt16), new Type[] { typeof(Vector128<Byte>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int16), new Type[] { typeof(Vector128<Byte>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr))
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt16>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int16>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_LoadAligned()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt16), new Type[] { typeof(Vector128<Byte>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int16), new Type[] { typeof(Vector128<Byte>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr))
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt16>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int16>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
- var result = Avx2.ConvertToVector256UInt16(
+ var result = Avx2.ConvertToVector256Int16(
_clsVar
);
public void RunLclVarScenario_UnsafeRead()
{
var firstOp = Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr);
- var result = Avx2.ConvertToVector256UInt16(firstOp);
+ var result = Avx2.ConvertToVector256Int16(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclVarScenario_Load()
{
var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr));
- var result = Avx2.ConvertToVector256UInt16(firstOp);
+ var result = Avx2.ConvertToVector256Int16(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclVarScenario_LoadAligned()
{
var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr));
- var result = Avx2.ConvertToVector256UInt16(firstOp);
+ var result = Avx2.ConvertToVector256Int16(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclFldScenario()
{
- var test = new SimpleUnaryOpTest__ConvertToVector256UInt16Byte();
- var result = Avx2.ConvertToVector256UInt16(test._fld);
+ var test = new SimpleUnaryOpTest__ConvertToVector256Int16Byte();
+ var result = Avx2.ConvertToVector256Int16(test._fld);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
public void RunFldScenario()
{
- var result = Avx2.ConvertToVector256UInt16(_fld);
+ var result = Avx2.ConvertToVector256Int16(_fld);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld, _dataTable.outArrayPtr);
if (!Succeeded)
{
- Console.WriteLine($"{nameof(Avx2)}.{nameof(Avx2.ConvertToVector256UInt16)}<UInt16>(Vector128<Byte>): {method} failed:");
+ Console.WriteLine($"{nameof(Avx2)}.{nameof(Avx2.ConvertToVector256Int16)}<UInt16>(Vector128<Byte>): {method} failed:");
Console.WriteLine($" firstOp: ({string.Join(", ", firstOp)})");
Console.WriteLine($" result: ({string.Join(", ", result)})");
Console.WriteLine();
{
public static partial class Program
{
- private static void ConvertToVector256UInt32Byte()
+ private static void ConvertToVector256Int32Byte()
{
- var test = new SimpleUnaryOpTest__ConvertToVector256UInt32Byte();
+ var test = new SimpleUnaryOpTest__ConvertToVector256Int32Byte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleUnaryOpTest__ConvertToVector256UInt32Byte
+ public sealed unsafe class SimpleUnaryOpTest__ConvertToVector256Int32Byte
{
private const int VectorSize = 32;
private SimpleUnaryOpTest__DataTable<UInt32, Byte> _dataTable;
- static SimpleUnaryOpTest__ConvertToVector256UInt32Byte()
+ static SimpleUnaryOpTest__ConvertToVector256Int32Byte()
{
var random = new Random();
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Byte>, byte>(ref _clsVar), ref Unsafe.As<Byte, byte>(ref _data[0]), 16);
}
- public SimpleUnaryOpTest__ConvertToVector256UInt32Byte()
+ public SimpleUnaryOpTest__ConvertToVector256Int32Byte()
{
Succeeded = true;
public void RunBasicScenario_UnsafeRead()
{
- var result = Avx2.ConvertToVector256UInt32(
+ var result = Avx2.ConvertToVector256Int32(
Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr)
);
public void RunBasicScenario_Load()
{
- var result = Avx2.ConvertToVector256UInt32(
+ var result = Avx2.ConvertToVector256Int32(
Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr))
);
public void RunBasicScenario_LoadAligned()
{
- var result = Avx2.ConvertToVector256UInt32(
+ var result = Avx2.ConvertToVector256Int32(
Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr))
);
public void RunReflectionScenario_UnsafeRead()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt32), new Type[] { typeof(Vector128<Byte>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<Byte>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr)
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt32>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt32), new Type[] { typeof(Vector128<Byte>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<Byte>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr))
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt32>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_LoadAligned()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt32), new Type[] { typeof(Vector128<Byte>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<Byte>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr))
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt32>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
- var result = Avx2.ConvertToVector256UInt32(
+ var result = Avx2.ConvertToVector256Int32(
_clsVar
);
public void RunLclVarScenario_UnsafeRead()
{
var firstOp = Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr);
- var result = Avx2.ConvertToVector256UInt32(firstOp);
+ var result = Avx2.ConvertToVector256Int32(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclVarScenario_Load()
{
var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr));
- var result = Avx2.ConvertToVector256UInt32(firstOp);
+ var result = Avx2.ConvertToVector256Int32(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclVarScenario_LoadAligned()
{
var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr));
- var result = Avx2.ConvertToVector256UInt32(firstOp);
+ var result = Avx2.ConvertToVector256Int32(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclFldScenario()
{
- var test = new SimpleUnaryOpTest__ConvertToVector256UInt32Byte();
- var result = Avx2.ConvertToVector256UInt32(test._fld);
+ var test = new SimpleUnaryOpTest__ConvertToVector256Int32Byte();
+ var result = Avx2.ConvertToVector256Int32(test._fld);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
public void RunFldScenario()
{
- var result = Avx2.ConvertToVector256UInt32(_fld);
+ var result = Avx2.ConvertToVector256Int32(_fld);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld, _dataTable.outArrayPtr);
if (!Succeeded)
{
- Console.WriteLine($"{nameof(Avx2)}.{nameof(Avx2.ConvertToVector256UInt32)}<UInt32>(Vector128<Byte>): {method} failed:");
+ Console.WriteLine($"{nameof(Avx2)}.{nameof(Avx2.ConvertToVector256Int32)}<UInt32>(Vector128<Byte>): {method} failed:");
Console.WriteLine($" firstOp: ({string.Join(", ", firstOp)})");
Console.WriteLine($" result: ({string.Join(", ", result)})");
Console.WriteLine();
{
public static partial class Program
{
- private static void ConvertToVector256UInt32UInt16()
+ private static void ConvertToVector256Int32UInt16()
{
- var test = new SimpleUnaryOpTest__ConvertToVector256UInt32UInt16();
+ var test = new SimpleUnaryOpTest__ConvertToVector256Int32UInt16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleUnaryOpTest__ConvertToVector256UInt32UInt16
+ public sealed unsafe class SimpleUnaryOpTest__ConvertToVector256Int32UInt16
{
private const int VectorSize = 32;
private SimpleUnaryOpTest__DataTable<UInt32, UInt16> _dataTable;
- static SimpleUnaryOpTest__ConvertToVector256UInt32UInt16()
+ static SimpleUnaryOpTest__ConvertToVector256Int32UInt16()
{
var random = new Random();
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar), ref Unsafe.As<UInt16, byte>(ref _data[0]), 16);
}
- public SimpleUnaryOpTest__ConvertToVector256UInt32UInt16()
+ public SimpleUnaryOpTest__ConvertToVector256Int32UInt16()
{
Succeeded = true;
public void RunBasicScenario_UnsafeRead()
{
- var result = Avx2.ConvertToVector256UInt32(
+ var result = Avx2.ConvertToVector256Int32(
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArrayPtr)
);
public void RunBasicScenario_Load()
{
- var result = Avx2.ConvertToVector256UInt32(
+ var result = Avx2.ConvertToVector256Int32(
Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr))
);
public void RunBasicScenario_LoadAligned()
{
- var result = Avx2.ConvertToVector256UInt32(
+ var result = Avx2.ConvertToVector256Int32(
Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr))
);
public void RunReflectionScenario_UnsafeRead()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt32), new Type[] { typeof(Vector128<UInt16>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArrayPtr)
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt32>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt32), new Type[] { typeof(Vector128<UInt16>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr))
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt32>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_LoadAligned()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt32), new Type[] { typeof(Vector128<UInt16>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr))
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt32>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
- var result = Avx2.ConvertToVector256UInt32(
+ var result = Avx2.ConvertToVector256Int32(
_clsVar
);
public void RunLclVarScenario_UnsafeRead()
{
var firstOp = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArrayPtr);
- var result = Avx2.ConvertToVector256UInt32(firstOp);
+ var result = Avx2.ConvertToVector256Int32(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclVarScenario_Load()
{
var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr));
- var result = Avx2.ConvertToVector256UInt32(firstOp);
+ var result = Avx2.ConvertToVector256Int32(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclVarScenario_LoadAligned()
{
var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr));
- var result = Avx2.ConvertToVector256UInt32(firstOp);
+ var result = Avx2.ConvertToVector256Int32(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclFldScenario()
{
- var test = new SimpleUnaryOpTest__ConvertToVector256UInt32UInt16();
- var result = Avx2.ConvertToVector256UInt32(test._fld);
+ var test = new SimpleUnaryOpTest__ConvertToVector256Int32UInt16();
+ var result = Avx2.ConvertToVector256Int32(test._fld);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
public void RunFldScenario()
{
- var result = Avx2.ConvertToVector256UInt32(_fld);
+ var result = Avx2.ConvertToVector256Int32(_fld);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld, _dataTable.outArrayPtr);
if (!Succeeded)
{
- Console.WriteLine($"{nameof(Avx2)}.{nameof(Avx2.ConvertToVector256UInt32)}<UInt32>(Vector128<UInt16>): {method} failed:");
+ Console.WriteLine($"{nameof(Avx2)}.{nameof(Avx2.ConvertToVector256Int32)}<UInt32>(Vector128<UInt16>): {method} failed:");
Console.WriteLine($" firstOp: ({string.Join(", ", firstOp)})");
Console.WriteLine($" result: ({string.Join(", ", result)})");
Console.WriteLine();
{
public static partial class Program
{
- private static void ConvertToVector256UInt64Byte()
+ private static void ConvertToVector256Int64Byte()
{
- var test = new SimpleUnaryOpTest__ConvertToVector256UInt64Byte();
+ var test = new SimpleUnaryOpTest__ConvertToVector256Int64Byte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleUnaryOpTest__ConvertToVector256UInt64Byte
+ public sealed unsafe class SimpleUnaryOpTest__ConvertToVector256Int64Byte
{
private const int VectorSize = 32;
private SimpleUnaryOpTest__DataTable<UInt64, Byte> _dataTable;
- static SimpleUnaryOpTest__ConvertToVector256UInt64Byte()
+ static SimpleUnaryOpTest__ConvertToVector256Int64Byte()
{
var random = new Random();
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Byte>, byte>(ref _clsVar), ref Unsafe.As<Byte, byte>(ref _data[0]), 16);
}
- public SimpleUnaryOpTest__ConvertToVector256UInt64Byte()
+ public SimpleUnaryOpTest__ConvertToVector256Int64Byte()
{
Succeeded = true;
public void RunBasicScenario_UnsafeRead()
{
- var result = Avx2.ConvertToVector256UInt64(
+ var result = Avx2.ConvertToVector256Int64(
Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr)
);
public void RunBasicScenario_Load()
{
- var result = Avx2.ConvertToVector256UInt64(
+ var result = Avx2.ConvertToVector256Int64(
Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr))
);
public void RunBasicScenario_LoadAligned()
{
- var result = Avx2.ConvertToVector256UInt64(
+ var result = Avx2.ConvertToVector256Int64(
Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr))
);
public void RunReflectionScenario_UnsafeRead()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt64), new Type[] { typeof(Vector128<Byte>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<Byte>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr)
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt64>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt64), new Type[] { typeof(Vector128<Byte>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<Byte>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr))
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt64>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_LoadAligned()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt64), new Type[] { typeof(Vector128<Byte>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<Byte>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr))
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt64>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
- var result = Avx2.ConvertToVector256UInt64(
+ var result = Avx2.ConvertToVector256Int64(
_clsVar
);
public void RunLclVarScenario_UnsafeRead()
{
var firstOp = Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr);
- var result = Avx2.ConvertToVector256UInt64(firstOp);
+ var result = Avx2.ConvertToVector256Int64(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclVarScenario_Load()
{
var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr));
- var result = Avx2.ConvertToVector256UInt64(firstOp);
+ var result = Avx2.ConvertToVector256Int64(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclVarScenario_LoadAligned()
{
var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr));
- var result = Avx2.ConvertToVector256UInt64(firstOp);
+ var result = Avx2.ConvertToVector256Int64(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclFldScenario()
{
- var test = new SimpleUnaryOpTest__ConvertToVector256UInt64Byte();
- var result = Avx2.ConvertToVector256UInt64(test._fld);
+ var test = new SimpleUnaryOpTest__ConvertToVector256Int64Byte();
+ var result = Avx2.ConvertToVector256Int64(test._fld);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
public void RunFldScenario()
{
- var result = Avx2.ConvertToVector256UInt64(_fld);
+ var result = Avx2.ConvertToVector256Int64(_fld);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld, _dataTable.outArrayPtr);
if (!Succeeded)
{
- Console.WriteLine($"{nameof(Avx2)}.{nameof(Avx2.ConvertToVector256UInt64)}<UInt64>(Vector128<Byte>): {method} failed:");
+ Console.WriteLine($"{nameof(Avx2)}.{nameof(Avx2.ConvertToVector256Int64)}<UInt64>(Vector128<Byte>): {method} failed:");
Console.WriteLine($" firstOp: ({string.Join(", ", firstOp)})");
Console.WriteLine($" result: ({string.Join(", ", result)})");
Console.WriteLine();
{
public static partial class Program
{
- private static void ConvertToVector256UInt64UInt16()
+ private static void ConvertToVector256Int64UInt16()
{
- var test = new SimpleUnaryOpTest__ConvertToVector256UInt64UInt16();
+ var test = new SimpleUnaryOpTest__ConvertToVector256Int64UInt16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleUnaryOpTest__ConvertToVector256UInt64UInt16
+ public sealed unsafe class SimpleUnaryOpTest__ConvertToVector256Int64UInt16
{
private const int VectorSize = 32;
private SimpleUnaryOpTest__DataTable<UInt64, UInt16> _dataTable;
- static SimpleUnaryOpTest__ConvertToVector256UInt64UInt16()
+ static SimpleUnaryOpTest__ConvertToVector256Int64UInt16()
{
var random = new Random();
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar), ref Unsafe.As<UInt16, byte>(ref _data[0]), 16);
}
- public SimpleUnaryOpTest__ConvertToVector256UInt64UInt16()
+ public SimpleUnaryOpTest__ConvertToVector256Int64UInt16()
{
Succeeded = true;
public void RunBasicScenario_UnsafeRead()
{
- var result = Avx2.ConvertToVector256UInt64(
+ var result = Avx2.ConvertToVector256Int64(
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArrayPtr)
);
public void RunBasicScenario_Load()
{
- var result = Avx2.ConvertToVector256UInt64(
+ var result = Avx2.ConvertToVector256Int64(
Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr))
);
public void RunBasicScenario_LoadAligned()
{
- var result = Avx2.ConvertToVector256UInt64(
+ var result = Avx2.ConvertToVector256Int64(
Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr))
);
public void RunReflectionScenario_UnsafeRead()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt64), new Type[] { typeof(Vector128<UInt16>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArrayPtr)
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt64>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt64), new Type[] { typeof(Vector128<UInt16>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr))
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt64>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_LoadAligned()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt64), new Type[] { typeof(Vector128<UInt16>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr))
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt64>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
- var result = Avx2.ConvertToVector256UInt64(
+ var result = Avx2.ConvertToVector256Int64(
_clsVar
);
public void RunLclVarScenario_UnsafeRead()
{
var firstOp = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArrayPtr);
- var result = Avx2.ConvertToVector256UInt64(firstOp);
+ var result = Avx2.ConvertToVector256Int64(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclVarScenario_Load()
{
var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr));
- var result = Avx2.ConvertToVector256UInt64(firstOp);
+ var result = Avx2.ConvertToVector256Int64(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclVarScenario_LoadAligned()
{
var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr));
- var result = Avx2.ConvertToVector256UInt64(firstOp);
+ var result = Avx2.ConvertToVector256Int64(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclFldScenario()
{
- var test = new SimpleUnaryOpTest__ConvertToVector256UInt64UInt16();
- var result = Avx2.ConvertToVector256UInt64(test._fld);
+ var test = new SimpleUnaryOpTest__ConvertToVector256Int64UInt16();
+ var result = Avx2.ConvertToVector256Int64(test._fld);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
public void RunFldScenario()
{
- var result = Avx2.ConvertToVector256UInt64(_fld);
+ var result = Avx2.ConvertToVector256Int64(_fld);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld, _dataTable.outArrayPtr);
if (!Succeeded)
{
- Console.WriteLine($"{nameof(Avx2)}.{nameof(Avx2.ConvertToVector256UInt64)}<UInt64>(Vector128<UInt16>): {method} failed:");
+ Console.WriteLine($"{nameof(Avx2)}.{nameof(Avx2.ConvertToVector256Int64)}<UInt64>(Vector128<UInt16>): {method} failed:");
Console.WriteLine($" firstOp: ({string.Join(", ", firstOp)})");
Console.WriteLine($" result: ({string.Join(", ", result)})");
Console.WriteLine();
{
public static partial class Program
{
- private static void ConvertToVector256UInt64UInt32()
+ private static void ConvertToVector256Int64UInt32()
{
- var test = new SimpleUnaryOpTest__ConvertToVector256UInt64UInt32();
+ var test = new SimpleUnaryOpTest__ConvertToVector256Int64UInt32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleUnaryOpTest__ConvertToVector256UInt64UInt32
+ public sealed unsafe class SimpleUnaryOpTest__ConvertToVector256Int64UInt32
{
private const int VectorSize = 32;
private SimpleUnaryOpTest__DataTable<UInt64, UInt32> _dataTable;
- static SimpleUnaryOpTest__ConvertToVector256UInt64UInt32()
+ static SimpleUnaryOpTest__ConvertToVector256Int64UInt32()
{
var random = new Random();
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar), ref Unsafe.As<UInt32, byte>(ref _data[0]), 16);
}
- public SimpleUnaryOpTest__ConvertToVector256UInt64UInt32()
+ public SimpleUnaryOpTest__ConvertToVector256Int64UInt32()
{
Succeeded = true;
public void RunBasicScenario_UnsafeRead()
{
- var result = Avx2.ConvertToVector256UInt64(
+ var result = Avx2.ConvertToVector256Int64(
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArrayPtr)
);
public void RunBasicScenario_Load()
{
- var result = Avx2.ConvertToVector256UInt64(
+ var result = Avx2.ConvertToVector256Int64(
Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr))
);
public void RunBasicScenario_LoadAligned()
{
- var result = Avx2.ConvertToVector256UInt64(
+ var result = Avx2.ConvertToVector256Int64(
Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr))
);
public void RunReflectionScenario_UnsafeRead()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt64), new Type[] { typeof(Vector128<UInt32>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArrayPtr)
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt64>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt64), new Type[] { typeof(Vector128<UInt32>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr))
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt64>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_LoadAligned()
{
- var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256UInt64), new Type[] { typeof(Vector128<UInt32>) })
+ var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr))
});
- Unsafe.Write(_dataTable.outArrayPtr, (Vector256<UInt64>)(result));
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result));
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
- var result = Avx2.ConvertToVector256UInt64(
+ var result = Avx2.ConvertToVector256Int64(
_clsVar
);
public void RunLclVarScenario_UnsafeRead()
{
var firstOp = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArrayPtr);
- var result = Avx2.ConvertToVector256UInt64(firstOp);
+ var result = Avx2.ConvertToVector256Int64(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclVarScenario_Load()
{
var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr));
- var result = Avx2.ConvertToVector256UInt64(firstOp);
+ var result = Avx2.ConvertToVector256Int64(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclVarScenario_LoadAligned()
{
var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr));
- var result = Avx2.ConvertToVector256UInt64(firstOp);
+ var result = Avx2.ConvertToVector256Int64(firstOp);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, _dataTable.outArrayPtr);
public void RunLclFldScenario()
{
- var test = new SimpleUnaryOpTest__ConvertToVector256UInt64UInt32();
- var result = Avx2.ConvertToVector256UInt64(test._fld);
+ var test = new SimpleUnaryOpTest__ConvertToVector256Int64UInt32();
+ var result = Avx2.ConvertToVector256Int64(test._fld);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld, _dataTable.outArrayPtr);
public void RunFldScenario()
{
- var result = Avx2.ConvertToVector256UInt64(_fld);
+ var result = Avx2.ConvertToVector256Int64(_fld);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld, _dataTable.outArrayPtr);
if (!Succeeded)
{
- Console.WriteLine($"{nameof(Avx2)}.{nameof(Avx2.ConvertToVector256UInt64)}<UInt64>(Vector128<UInt32>): {method} failed:");
+ Console.WriteLine($"{nameof(Avx2)}.{nameof(Avx2.ConvertToVector256Int64)}<UInt64>(Vector128<UInt32>): {method} failed:");
Console.WriteLine($" firstOp: ({string.Join(", ", firstOp)})");
Console.WriteLine($" result: ({string.Join(", ", result)})");
Console.WriteLine();
<Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
</ItemGroup>
<ItemGroup>
- <Compile Include="ConvertToVector256UInt16.Byte.cs" />
+ <Compile Include="ConvertToVector256Int16.Byte.cs" />
<Compile Include="ConvertToVector256Int16.SByte.cs" />
- <Compile Include="ConvertToVector256UInt32.Byte.cs" />
+ <Compile Include="ConvertToVector256Int32.Byte.cs" />
<Compile Include="ConvertToVector256Int32.Int16.cs" />
<Compile Include="ConvertToVector256Int32.SByte.cs" />
- <Compile Include="ConvertToVector256UInt32.UInt16.cs" />
- <Compile Include="ConvertToVector256UInt64.Byte.cs" />
+ <Compile Include="ConvertToVector256Int32.UInt16.cs" />
+ <Compile Include="ConvertToVector256Int64.Byte.cs" />
<Compile Include="ConvertToVector256Int64.Int16.cs" />
<Compile Include="ConvertToVector256Int64.Int32.cs" />
<Compile Include="ConvertToVector256Int64.SByte.cs" />
- <Compile Include="ConvertToVector256UInt64.UInt16.cs" />
- <Compile Include="ConvertToVector256UInt64.UInt32.cs" />
+ <Compile Include="ConvertToVector256Int64.UInt16.cs" />
+ <Compile Include="ConvertToVector256Int64.UInt32.cs" />
<Compile Include="Program.ConvertToVector256.cs" />
<Compile Include="..\Shared\Program.cs" />
<Compile Include="..\Shared\SimpleUnOpTest_DataTable.cs" />
<Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
</ItemGroup>
<ItemGroup>
- <Compile Include="ConvertToVector256UInt16.Byte.cs" />
+ <Compile Include="ConvertToVector256Int16.Byte.cs" />
<Compile Include="ConvertToVector256Int16.SByte.cs" />
- <Compile Include="ConvertToVector256UInt32.Byte.cs" />
+ <Compile Include="ConvertToVector256Int32.Byte.cs" />
<Compile Include="ConvertToVector256Int32.Int16.cs" />
<Compile Include="ConvertToVector256Int32.SByte.cs" />
- <Compile Include="ConvertToVector256UInt32.UInt16.cs" />
- <Compile Include="ConvertToVector256UInt64.Byte.cs" />
+ <Compile Include="ConvertToVector256Int32.UInt16.cs" />
+ <Compile Include="ConvertToVector256Int64.Byte.cs" />
<Compile Include="ConvertToVector256Int64.Int16.cs" />
<Compile Include="ConvertToVector256Int64.Int32.cs" />
<Compile Include="ConvertToVector256Int64.SByte.cs" />
- <Compile Include="ConvertToVector256UInt64.UInt16.cs" />
- <Compile Include="ConvertToVector256UInt64.UInt32.cs" />
+ <Compile Include="ConvertToVector256Int64.UInt16.cs" />
+ <Compile Include="ConvertToVector256Int64.UInt32.cs" />
<Compile Include="Program.ConvertToVector256.cs" />
<Compile Include="..\Shared\Program.cs" />
<Compile Include="..\Shared\SimpleUnOpTest_DataTable.cs" />
static Program()
{
TestList = new Dictionary<string, Action>() {
- ["ConvertToVector256UInt16.Byte"] = ConvertToVector256UInt16Byte,
+ ["ConvertToVector256Int16.Byte"] = ConvertToVector256Int16Byte,
["ConvertToVector256Int16.SByte"] = ConvertToVector256Int16SByte,
- ["ConvertToVector256UInt32.Byte"] = ConvertToVector256UInt32Byte,
+ ["ConvertToVector256Int32.Byte"] = ConvertToVector256Int32Byte,
["ConvertToVector256Int32.Int16"] = ConvertToVector256Int32Int16,
["ConvertToVector256Int32.SByte"] = ConvertToVector256Int32SByte,
- ["ConvertToVector256UInt32.UInt16"] = ConvertToVector256UInt32UInt16,
- ["ConvertToVector256UInt64.Byte"] = ConvertToVector256UInt64Byte,
+ ["ConvertToVector256Int32.UInt16"] = ConvertToVector256Int32UInt16,
+ ["ConvertToVector256Int64.Byte"] = ConvertToVector256Int64Byte,
["ConvertToVector256Int64.Int16"] = ConvertToVector256Int64Int16,
["ConvertToVector256Int64.Int32"] = ConvertToVector256Int64Int32,
["ConvertToVector256Int64.SByte"] = ConvertToVector256Int64SByte,
- ["ConvertToVector256UInt64.UInt16"] = ConvertToVector256UInt64UInt16,
- ["ConvertToVector256UInt64.UInt32"] = ConvertToVector256UInt64UInt32,
+ ["ConvertToVector256Int64.UInt16"] = ConvertToVector256Int64UInt16,
+ ["ConvertToVector256Int64.UInt32"] = ConvertToVector256Int64UInt32,
};
}
}
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "And", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "(BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "AndNot", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(~BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "(~BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] == right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareEqualScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareEqualOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] == right[0]) != result"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareEqualUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] == right[0]) != result"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarOrderedEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] == right[0]) != result"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarUnorderedEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] == right[0]) != result"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] > right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] > right[0]) != result"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] > right[0]) != result"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarOrderedGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] > right[0]) != result"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarUnorderedGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] > right[0]) != result"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] >= right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanOrEqualScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanOrEqualOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] >= right[0]) != result"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanOrEqualUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] >= right[0]) != result"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarOrderedGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] >= right[0]) != result"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarUnorderedGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] >= right[0]) != result"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] < right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] < right[0]) != result"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] < right[0]) != result"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarOrderedLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] < right[0]) != result"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarUnorderedLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] < right[0]) != result"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] <= right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanOrEqualScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanOrEqualOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] <= right[0]) != result"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanOrEqualUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] <= right[0]) != result"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarLessThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarOrderedLessThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] <= right[0]) != result"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarUnorderedLessThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] <= right[0]) != result"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] != right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotEqualScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotEqualOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] != right[0]) != result"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotEqualUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] != right[0]) != result"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarNotEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarOrderedNotEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] != right[0]) != result"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarUnorderedNotEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(left[0] != right[0]) != result"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] > right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotGreaterThanScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarNotGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] >= right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotGreaterThanOrEqualScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarNotGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] < right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotLessThanScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarNotLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotLessThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] <= right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotLessThanOrEqualScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarNotLessThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareOrdered", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((!float.IsNaN(left[0]) && !float.IsNaN(right[0])) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((!float.IsNaN(left[i]) && !float.IsNaN(right[i])) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((!float.IsNaN(left[0]) && !float.IsNaN(right[0])) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarOrdered", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((!float.IsNaN(left[0]) && !float.IsNaN(right[0])) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareUnordered", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((float.IsNaN(left[0]) || float.IsNaN(right[0])) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((float.IsNaN(left[i]) || float.IsNaN(right[i])) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((float.IsNaN(left[0]) || float.IsNaN(right[0])) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareScalarUnordered", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((float.IsNaN(left[0]) || float.IsNaN(right[0])) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
("SimpleBinOpConvTest.template",new Dictionary<string, string>{["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "ConvertScalarToVector128Single", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "(float)right != result[0]"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "Divide", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] / right[0]) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i] / right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "DivideScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] / right[0]) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((sbyte)(-1)) : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((ushort)(-1)) : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((ushort)(-1)) : 0)"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((uint)(-1)) : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((uint)(-1)) : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqualScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqualOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] == right[0]) != result"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqualUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] == right[0]) != result"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarOrderedEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] == right[0]) != result"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarUnorderedEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] == right[0]) != result"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] > right[i]) ? -1 : 0)"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? unchecked((short)(-1)) : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? unchecked((short)(-1)) : 0)"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? unchecked((int)(-1)) : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? unchecked((int)(-1)) : 0)"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? unchecked((sbyte)(-1)) : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThanScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThanOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] > right[0]) != result"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThanUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] > right[0]) != result"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarOrderedGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] > right[0]) != result"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarUnorderedGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] > right[0]) != result"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] >= right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThanOrEqualScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThanOrEqualOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] >= right[0]) != result"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThanOrEqualUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] >= right[0]) != result"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarOrderedGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] >= right[0]) != result"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarUnorderedGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] >= right[0]) != result"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] < right[i]) ? -1 : 0)"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? unchecked((short)(-1)) : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? unchecked((short)(-1)) : 0)"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? unchecked((int)(-1)) : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? unchecked((int)(-1)) : 0)"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? unchecked((sbyte)(-1)) : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThanScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThanOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] < right[0]) != result"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThanUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] < right[0]) != result"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarOrderedLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] < right[0]) != result"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarUnorderedLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] < right[0]) != result"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] <= right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThanOrEqualScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThanOrEqualOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] <= right[0]) != result"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThanOrEqualUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] <= right[0]) != result"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarLessThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarOrderedLessThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] <= right[0]) != result"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarUnorderedLessThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] <= right[0]) != result"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] != right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotEqualScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotEqualOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] != right[0]) != result"}),
- ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotEqualUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] != right[0]) != result"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarNotEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarOrderedNotEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] != right[0]) != result"}),
+ ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarUnorderedNotEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean",["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(left[0] != right[0]) != result"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] > right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotGreaterThanScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarNotGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] >= right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotGreaterThanOrEqualScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarNotGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] < right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotLessThanScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarNotLessThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotLessThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] <= right[i]) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotLessThanOrEqualScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarNotLessThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareOrdered", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((!double.IsNaN(left[0]) && !double.IsNaN(right[0])) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((!double.IsNaN(left[i]) && !double.IsNaN(right[i])) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareOrderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((!double.IsNaN(left[0]) && !double.IsNaN(right[0])) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarOrdered", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((!double.IsNaN(left[0]) && !double.IsNaN(right[0])) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareUnordered", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((double.IsNaN(left[0]) || double.IsNaN(right[0])) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((double.IsNaN(left[i]) || double.IsNaN(right[i])) ? -1 : 0)"}),
- ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareUnorderedScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((double.IsNaN(left[0]) || double.IsNaN(right[0])) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareScalarUnordered", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((double.IsNaN(left[0]) || double.IsNaN(right[0])) ? -1 : 0)", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
("SimdScalarUnOpConvTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ConvertToInt32", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(int)Math.Round(firstOp[0]) != result"}),
("SimdScalarUnOpConvTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ConvertToInt32", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "firstOp[0] != result"}),
("SimdScalarUnOpConvTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ConvertToInt32WithTruncation", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(int) firstOp[0] != result"}),
{
public static partial class Program
{
- private static void CompareEqualScalarSingle()
+ private static void CompareScalarEqualSingle()
{
- var test = new SimpleBinaryOpTest__CompareEqualScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarEqualSingle();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareEqualScalarSingle
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarEqualSingle
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareEqualScalarSingle testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarEqualSingle testClass)
{
- var result = Sse.CompareEqualScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareEqualScalarSingle testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarEqualSingle testClass)
{
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareEqualScalar(
+ var result = Sse.CompareScalarEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Single, Single, Single> _dataTable;
- static SimpleBinaryOpTest__CompareEqualScalarSingle()
+ static SimpleBinaryOpTest__CompareScalarEqualSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public SimpleBinaryOpTest__CompareEqualScalarSingle()
+ public SimpleBinaryOpTest__CompareScalarEqualSingle()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareEqualScalar(
+ var result = Sse.CompareScalarEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareEqualScalar(
+ var result = Sse.CompareScalarEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareEqualScalar(
+ var result = Sse.CompareScalarEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareEqualScalar(
+ var result = Sse.CompareScalarEqual(
_clsVar1,
_clsVar2
);
fixed (Vector128<Single>* pClsVar1 = &_clsVar1)
fixed (Vector128<Single>* pClsVar2 = &_clsVar2)
{
- var result = Sse.CompareEqualScalar(
+ var result = Sse.CompareScalarEqual(
Sse.LoadVector128((Single*)(pClsVar1)),
Sse.LoadVector128((Single*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareEqualScalar(left, right);
+ var result = Sse.CompareScalarEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareEqualScalar(left, right);
+ var result = Sse.CompareScalarEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareEqualScalar(left, right);
+ var result = Sse.CompareScalarEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareEqualScalarSingle();
- var result = Sse.CompareEqualScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarEqualSingle();
+ var result = Sse.CompareScalarEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareEqualScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarEqualSingle();
fixed (Vector128<Single>* pFld1 = &test._fld1)
fixed (Vector128<Single>* pFld2 = &test._fld2)
{
- var result = Sse.CompareEqualScalar(
+ var result = Sse.CompareScalarEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareEqualScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareEqualScalar(
+ var result = Sse.CompareScalarEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareEqualScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse.CompareEqualScalar(
+ var result = Sse.CompareScalarEqual(
Sse.LoadVector128((Single*)(&test._fld1)),
Sse.LoadVector128((Single*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareEqualScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarEqual)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareGreaterThanScalarSingle()
+ private static void CompareScalarGreaterThanSingle()
{
- var test = new SimpleBinaryOpTest__CompareGreaterThanScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarGreaterThanSingle();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareGreaterThanScalarSingle
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarGreaterThanSingle
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareGreaterThanScalarSingle testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarGreaterThanSingle testClass)
{
- var result = Sse.CompareGreaterThanScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarGreaterThan(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareGreaterThanScalarSingle testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarGreaterThanSingle testClass)
{
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareGreaterThanScalar(
+ var result = Sse.CompareScalarGreaterThan(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Single, Single, Single> _dataTable;
- static SimpleBinaryOpTest__CompareGreaterThanScalarSingle()
+ static SimpleBinaryOpTest__CompareScalarGreaterThanSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public SimpleBinaryOpTest__CompareGreaterThanScalarSingle()
+ public SimpleBinaryOpTest__CompareScalarGreaterThanSingle()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareGreaterThanScalar(
+ var result = Sse.CompareScalarGreaterThan(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareGreaterThanScalar(
+ var result = Sse.CompareScalarGreaterThan(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareGreaterThanScalar(
+ var result = Sse.CompareScalarGreaterThan(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarGreaterThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarGreaterThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarGreaterThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareGreaterThanScalar(
+ var result = Sse.CompareScalarGreaterThan(
_clsVar1,
_clsVar2
);
fixed (Vector128<Single>* pClsVar1 = &_clsVar1)
fixed (Vector128<Single>* pClsVar2 = &_clsVar2)
{
- var result = Sse.CompareGreaterThanScalar(
+ var result = Sse.CompareScalarGreaterThan(
Sse.LoadVector128((Single*)(pClsVar1)),
Sse.LoadVector128((Single*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareGreaterThanScalar(left, right);
+ var result = Sse.CompareScalarGreaterThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareGreaterThanScalar(left, right);
+ var result = Sse.CompareScalarGreaterThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareGreaterThanScalar(left, right);
+ var result = Sse.CompareScalarGreaterThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareGreaterThanScalarSingle();
- var result = Sse.CompareGreaterThanScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarGreaterThanSingle();
+ var result = Sse.CompareScalarGreaterThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareGreaterThanScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarGreaterThanSingle();
fixed (Vector128<Single>* pFld1 = &test._fld1)
fixed (Vector128<Single>* pFld2 = &test._fld2)
{
- var result = Sse.CompareGreaterThanScalar(
+ var result = Sse.CompareScalarGreaterThan(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareGreaterThanScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarGreaterThan(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareGreaterThanScalar(
+ var result = Sse.CompareScalarGreaterThan(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareGreaterThanScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarGreaterThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse.CompareGreaterThanScalar(
+ var result = Sse.CompareScalarGreaterThan(
Sse.LoadVector128((Single*)(&test._fld1)),
Sse.LoadVector128((Single*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarGreaterThan)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareGreaterThanOrEqualScalarSingle()
+ private static void CompareScalarGreaterThanOrEqualSingle()
{
- var test = new SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualSingle();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarSingle
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualSingle
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarSingle testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualSingle testClass)
{
- var result = Sse.CompareGreaterThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarGreaterThanOrEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarSingle testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualSingle testClass)
{
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarGreaterThanOrEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Single, Single, Single> _dataTable;
- static SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarSingle()
+ static SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarSingle()
+ public SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualSingle()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarGreaterThanOrEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarGreaterThanOrEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarGreaterThanOrEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarGreaterThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarGreaterThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarGreaterThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarGreaterThanOrEqual(
_clsVar1,
_clsVar2
);
fixed (Vector128<Single>* pClsVar1 = &_clsVar1)
fixed (Vector128<Single>* pClsVar2 = &_clsVar2)
{
- var result = Sse.CompareGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarGreaterThanOrEqual(
Sse.LoadVector128((Single*)(pClsVar1)),
Sse.LoadVector128((Single*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareGreaterThanOrEqualScalar(left, right);
+ var result = Sse.CompareScalarGreaterThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareGreaterThanOrEqualScalar(left, right);
+ var result = Sse.CompareScalarGreaterThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareGreaterThanOrEqualScalar(left, right);
+ var result = Sse.CompareScalarGreaterThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarSingle();
- var result = Sse.CompareGreaterThanOrEqualScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualSingle();
+ var result = Sse.CompareScalarGreaterThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualSingle();
fixed (Vector128<Single>* pFld1 = &test._fld1)
fixed (Vector128<Single>* pFld2 = &test._fld2)
{
- var result = Sse.CompareGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarGreaterThanOrEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareGreaterThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarGreaterThanOrEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarGreaterThanOrEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareGreaterThanOrEqualScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarGreaterThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse.CompareGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarGreaterThanOrEqual(
Sse.LoadVector128((Single*)(&test._fld1)),
Sse.LoadVector128((Single*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanOrEqualScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarGreaterThanOrEqual)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareLessThanScalarSingle()
+ private static void CompareScalarLessThanSingle()
{
- var test = new SimpleBinaryOpTest__CompareLessThanScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarLessThanSingle();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareLessThanScalarSingle
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarLessThanSingle
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareLessThanScalarSingle testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarLessThanSingle testClass)
{
- var result = Sse.CompareLessThanScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarLessThan(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareLessThanScalarSingle testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarLessThanSingle testClass)
{
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareLessThanScalar(
+ var result = Sse.CompareScalarLessThan(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Single, Single, Single> _dataTable;
- static SimpleBinaryOpTest__CompareLessThanScalarSingle()
+ static SimpleBinaryOpTest__CompareScalarLessThanSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public SimpleBinaryOpTest__CompareLessThanScalarSingle()
+ public SimpleBinaryOpTest__CompareScalarLessThanSingle()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareLessThanScalar(
+ var result = Sse.CompareScalarLessThan(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareLessThanScalar(
+ var result = Sse.CompareScalarLessThan(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareLessThanScalar(
+ var result = Sse.CompareScalarLessThan(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarLessThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarLessThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarLessThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareLessThanScalar(
+ var result = Sse.CompareScalarLessThan(
_clsVar1,
_clsVar2
);
fixed (Vector128<Single>* pClsVar1 = &_clsVar1)
fixed (Vector128<Single>* pClsVar2 = &_clsVar2)
{
- var result = Sse.CompareLessThanScalar(
+ var result = Sse.CompareScalarLessThan(
Sse.LoadVector128((Single*)(pClsVar1)),
Sse.LoadVector128((Single*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareLessThanScalar(left, right);
+ var result = Sse.CompareScalarLessThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareLessThanScalar(left, right);
+ var result = Sse.CompareScalarLessThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareLessThanScalar(left, right);
+ var result = Sse.CompareScalarLessThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareLessThanScalarSingle();
- var result = Sse.CompareLessThanScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarLessThanSingle();
+ var result = Sse.CompareScalarLessThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareLessThanScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarLessThanSingle();
fixed (Vector128<Single>* pFld1 = &test._fld1)
fixed (Vector128<Single>* pFld2 = &test._fld2)
{
- var result = Sse.CompareLessThanScalar(
+ var result = Sse.CompareScalarLessThan(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareLessThanScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarLessThan(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareLessThanScalar(
+ var result = Sse.CompareScalarLessThan(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareLessThanScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarLessThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse.CompareLessThanScalar(
+ var result = Sse.CompareScalarLessThan(
Sse.LoadVector128((Single*)(&test._fld1)),
Sse.LoadVector128((Single*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarLessThan)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareLessThanOrEqualScalarSingle()
+ private static void CompareScalarLessThanOrEqualSingle()
{
- var test = new SimpleBinaryOpTest__CompareLessThanOrEqualScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarLessThanOrEqualSingle();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareLessThanOrEqualScalarSingle
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarLessThanOrEqualSingle
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareLessThanOrEqualScalarSingle testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarLessThanOrEqualSingle testClass)
{
- var result = Sse.CompareLessThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarLessThanOrEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareLessThanOrEqualScalarSingle testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarLessThanOrEqualSingle testClass)
{
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareLessThanOrEqualScalar(
+ var result = Sse.CompareScalarLessThanOrEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Single, Single, Single> _dataTable;
- static SimpleBinaryOpTest__CompareLessThanOrEqualScalarSingle()
+ static SimpleBinaryOpTest__CompareScalarLessThanOrEqualSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public SimpleBinaryOpTest__CompareLessThanOrEqualScalarSingle()
+ public SimpleBinaryOpTest__CompareScalarLessThanOrEqualSingle()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareLessThanOrEqualScalar(
+ var result = Sse.CompareScalarLessThanOrEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareLessThanOrEqualScalar(
+ var result = Sse.CompareScalarLessThanOrEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareLessThanOrEqualScalar(
+ var result = Sse.CompareScalarLessThanOrEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarLessThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarLessThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarLessThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareLessThanOrEqualScalar(
+ var result = Sse.CompareScalarLessThanOrEqual(
_clsVar1,
_clsVar2
);
fixed (Vector128<Single>* pClsVar1 = &_clsVar1)
fixed (Vector128<Single>* pClsVar2 = &_clsVar2)
{
- var result = Sse.CompareLessThanOrEqualScalar(
+ var result = Sse.CompareScalarLessThanOrEqual(
Sse.LoadVector128((Single*)(pClsVar1)),
Sse.LoadVector128((Single*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareLessThanOrEqualScalar(left, right);
+ var result = Sse.CompareScalarLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareLessThanOrEqualScalar(left, right);
+ var result = Sse.CompareScalarLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareLessThanOrEqualScalar(left, right);
+ var result = Sse.CompareScalarLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareLessThanOrEqualScalarSingle();
- var result = Sse.CompareLessThanOrEqualScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarLessThanOrEqualSingle();
+ var result = Sse.CompareScalarLessThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareLessThanOrEqualScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarLessThanOrEqualSingle();
fixed (Vector128<Single>* pFld1 = &test._fld1)
fixed (Vector128<Single>* pFld2 = &test._fld2)
{
- var result = Sse.CompareLessThanOrEqualScalar(
+ var result = Sse.CompareScalarLessThanOrEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareLessThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarLessThanOrEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareLessThanOrEqualScalar(
+ var result = Sse.CompareScalarLessThanOrEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareLessThanOrEqualScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarLessThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse.CompareLessThanOrEqualScalar(
+ var result = Sse.CompareScalarLessThanOrEqual(
Sse.LoadVector128((Single*)(&test._fld1)),
Sse.LoadVector128((Single*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanOrEqualScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarLessThanOrEqual)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotEqualScalarSingle()
+ private static void CompareScalarNotEqualSingle()
{
- var test = new SimpleBinaryOpTest__CompareNotEqualScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarNotEqualSingle();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareNotEqualScalarSingle
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarNotEqualSingle
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareNotEqualScalarSingle testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarNotEqualSingle testClass)
{
- var result = Sse.CompareNotEqualScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarNotEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareNotEqualScalarSingle testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarNotEqualSingle testClass)
{
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareNotEqualScalar(
+ var result = Sse.CompareScalarNotEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Single, Single, Single> _dataTable;
- static SimpleBinaryOpTest__CompareNotEqualScalarSingle()
+ static SimpleBinaryOpTest__CompareScalarNotEqualSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public SimpleBinaryOpTest__CompareNotEqualScalarSingle()
+ public SimpleBinaryOpTest__CompareScalarNotEqualSingle()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareNotEqualScalar(
+ var result = Sse.CompareScalarNotEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareNotEqualScalar(
+ var result = Sse.CompareScalarNotEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareNotEqualScalar(
+ var result = Sse.CompareScalarNotEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareNotEqualScalar(
+ var result = Sse.CompareScalarNotEqual(
_clsVar1,
_clsVar2
);
fixed (Vector128<Single>* pClsVar1 = &_clsVar1)
fixed (Vector128<Single>* pClsVar2 = &_clsVar2)
{
- var result = Sse.CompareNotEqualScalar(
+ var result = Sse.CompareScalarNotEqual(
Sse.LoadVector128((Single*)(pClsVar1)),
Sse.LoadVector128((Single*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareNotEqualScalar(left, right);
+ var result = Sse.CompareScalarNotEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotEqualScalar(left, right);
+ var result = Sse.CompareScalarNotEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotEqualScalar(left, right);
+ var result = Sse.CompareScalarNotEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareNotEqualScalarSingle();
- var result = Sse.CompareNotEqualScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarNotEqualSingle();
+ var result = Sse.CompareScalarNotEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareNotEqualScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarNotEqualSingle();
fixed (Vector128<Single>* pFld1 = &test._fld1)
fixed (Vector128<Single>* pFld2 = &test._fld2)
{
- var result = Sse.CompareNotEqualScalar(
+ var result = Sse.CompareScalarNotEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareNotEqualScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarNotEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareNotEqualScalar(
+ var result = Sse.CompareScalarNotEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareNotEqualScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarNotEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse.CompareNotEqualScalar(
+ var result = Sse.CompareScalarNotEqual(
Sse.LoadVector128((Single*)(&test._fld1)),
Sse.LoadVector128((Single*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotEqualScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarNotEqual)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotGreaterThanScalarSingle()
+ private static void CompareScalarNotGreaterThanSingle()
{
- var test = new SimpleBinaryOpTest__CompareNotGreaterThanScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarNotGreaterThanSingle();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareNotGreaterThanScalarSingle
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarNotGreaterThanSingle
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareNotGreaterThanScalarSingle testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarNotGreaterThanSingle testClass)
{
- var result = Sse.CompareNotGreaterThanScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarNotGreaterThan(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareNotGreaterThanScalarSingle testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarNotGreaterThanSingle testClass)
{
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareNotGreaterThanScalar(
+ var result = Sse.CompareScalarNotGreaterThan(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Single, Single, Single> _dataTable;
- static SimpleBinaryOpTest__CompareNotGreaterThanScalarSingle()
+ static SimpleBinaryOpTest__CompareScalarNotGreaterThanSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public SimpleBinaryOpTest__CompareNotGreaterThanScalarSingle()
+ public SimpleBinaryOpTest__CompareScalarNotGreaterThanSingle()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareNotGreaterThanScalar(
+ var result = Sse.CompareScalarNotGreaterThan(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareNotGreaterThanScalar(
+ var result = Sse.CompareScalarNotGreaterThan(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareNotGreaterThanScalar(
+ var result = Sse.CompareScalarNotGreaterThan(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotGreaterThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotGreaterThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotGreaterThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareNotGreaterThanScalar(
+ var result = Sse.CompareScalarNotGreaterThan(
_clsVar1,
_clsVar2
);
fixed (Vector128<Single>* pClsVar1 = &_clsVar1)
fixed (Vector128<Single>* pClsVar2 = &_clsVar2)
{
- var result = Sse.CompareNotGreaterThanScalar(
+ var result = Sse.CompareScalarNotGreaterThan(
Sse.LoadVector128((Single*)(pClsVar1)),
Sse.LoadVector128((Single*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareNotGreaterThanScalar(left, right);
+ var result = Sse.CompareScalarNotGreaterThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotGreaterThanScalar(left, right);
+ var result = Sse.CompareScalarNotGreaterThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotGreaterThanScalar(left, right);
+ var result = Sse.CompareScalarNotGreaterThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareNotGreaterThanScalarSingle();
- var result = Sse.CompareNotGreaterThanScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarNotGreaterThanSingle();
+ var result = Sse.CompareScalarNotGreaterThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareNotGreaterThanScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarNotGreaterThanSingle();
fixed (Vector128<Single>* pFld1 = &test._fld1)
fixed (Vector128<Single>* pFld2 = &test._fld2)
{
- var result = Sse.CompareNotGreaterThanScalar(
+ var result = Sse.CompareScalarNotGreaterThan(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareNotGreaterThanScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarNotGreaterThan(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareNotGreaterThanScalar(
+ var result = Sse.CompareScalarNotGreaterThan(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareNotGreaterThanScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarNotGreaterThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse.CompareNotGreaterThanScalar(
+ var result = Sse.CompareScalarNotGreaterThan(
Sse.LoadVector128((Single*)(&test._fld1)),
Sse.LoadVector128((Single*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotGreaterThanScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarNotGreaterThan)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotGreaterThanOrEqualScalarSingle()
+ private static void CompareScalarNotGreaterThanOrEqualSingle()
{
- var test = new SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualSingle();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarSingle
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualSingle
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarSingle testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualSingle testClass)
{
- var result = Sse.CompareNotGreaterThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarSingle testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualSingle testClass)
{
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Single, Single, Single> _dataTable;
- static SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarSingle()
+ static SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarSingle()
+ public SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualSingle()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanOrEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotGreaterThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanOrEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotGreaterThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanOrEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotGreaterThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(
_clsVar1,
_clsVar2
);
fixed (Vector128<Single>* pClsVar1 = &_clsVar1)
fixed (Vector128<Single>* pClsVar2 = &_clsVar2)
{
- var result = Sse.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(
Sse.LoadVector128((Single*)(pClsVar1)),
Sse.LoadVector128((Single*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareNotGreaterThanOrEqualScalar(left, right);
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotGreaterThanOrEqualScalar(left, right);
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotGreaterThanOrEqualScalar(left, right);
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarSingle();
- var result = Sse.CompareNotGreaterThanOrEqualScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualSingle();
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualSingle();
fixed (Vector128<Single>* pFld1 = &test._fld1)
fixed (Vector128<Single>* pFld2 = &test._fld2)
{
- var result = Sse.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareNotGreaterThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareNotGreaterThanOrEqualScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse.CompareScalarNotGreaterThanOrEqual(
Sse.LoadVector128((Single*)(&test._fld1)),
Sse.LoadVector128((Single*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotGreaterThanOrEqualScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarNotGreaterThanOrEqual)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotLessThanScalarSingle()
+ private static void CompareScalarNotLessThanSingle()
{
- var test = new SimpleBinaryOpTest__CompareNotLessThanScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarNotLessThanSingle();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareNotLessThanScalarSingle
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarNotLessThanSingle
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareNotLessThanScalarSingle testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarNotLessThanSingle testClass)
{
- var result = Sse.CompareNotLessThanScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarNotLessThan(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareNotLessThanScalarSingle testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarNotLessThanSingle testClass)
{
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareNotLessThanScalar(
+ var result = Sse.CompareScalarNotLessThan(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Single, Single, Single> _dataTable;
- static SimpleBinaryOpTest__CompareNotLessThanScalarSingle()
+ static SimpleBinaryOpTest__CompareScalarNotLessThanSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public SimpleBinaryOpTest__CompareNotLessThanScalarSingle()
+ public SimpleBinaryOpTest__CompareScalarNotLessThanSingle()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareNotLessThanScalar(
+ var result = Sse.CompareScalarNotLessThan(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareNotLessThanScalar(
+ var result = Sse.CompareScalarNotLessThan(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareNotLessThanScalar(
+ var result = Sse.CompareScalarNotLessThan(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotLessThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotLessThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotLessThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareNotLessThanScalar(
+ var result = Sse.CompareScalarNotLessThan(
_clsVar1,
_clsVar2
);
fixed (Vector128<Single>* pClsVar1 = &_clsVar1)
fixed (Vector128<Single>* pClsVar2 = &_clsVar2)
{
- var result = Sse.CompareNotLessThanScalar(
+ var result = Sse.CompareScalarNotLessThan(
Sse.LoadVector128((Single*)(pClsVar1)),
Sse.LoadVector128((Single*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareNotLessThanScalar(left, right);
+ var result = Sse.CompareScalarNotLessThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotLessThanScalar(left, right);
+ var result = Sse.CompareScalarNotLessThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotLessThanScalar(left, right);
+ var result = Sse.CompareScalarNotLessThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareNotLessThanScalarSingle();
- var result = Sse.CompareNotLessThanScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarNotLessThanSingle();
+ var result = Sse.CompareScalarNotLessThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareNotLessThanScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarNotLessThanSingle();
fixed (Vector128<Single>* pFld1 = &test._fld1)
fixed (Vector128<Single>* pFld2 = &test._fld2)
{
- var result = Sse.CompareNotLessThanScalar(
+ var result = Sse.CompareScalarNotLessThan(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareNotLessThanScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarNotLessThan(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareNotLessThanScalar(
+ var result = Sse.CompareScalarNotLessThan(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareNotLessThanScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarNotLessThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse.CompareNotLessThanScalar(
+ var result = Sse.CompareScalarNotLessThan(
Sse.LoadVector128((Single*)(&test._fld1)),
Sse.LoadVector128((Single*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotLessThanScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarNotLessThan)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotLessThanOrEqualScalarSingle()
+ private static void CompareScalarNotLessThanOrEqualSingle()
{
- var test = new SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualSingle();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarSingle
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualSingle
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarSingle testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualSingle testClass)
{
- var result = Sse.CompareNotLessThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarNotLessThanOrEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarSingle testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualSingle testClass)
{
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareNotLessThanOrEqualScalar(
+ var result = Sse.CompareScalarNotLessThanOrEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Single, Single, Single> _dataTable;
- static SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarSingle()
+ static SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarSingle()
+ public SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualSingle()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareNotLessThanOrEqualScalar(
+ var result = Sse.CompareScalarNotLessThanOrEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareNotLessThanOrEqualScalar(
+ var result = Sse.CompareScalarNotLessThanOrEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareNotLessThanOrEqualScalar(
+ var result = Sse.CompareScalarNotLessThanOrEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanOrEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotLessThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanOrEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotLessThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanOrEqualScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarNotLessThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareNotLessThanOrEqualScalar(
+ var result = Sse.CompareScalarNotLessThanOrEqual(
_clsVar1,
_clsVar2
);
fixed (Vector128<Single>* pClsVar1 = &_clsVar1)
fixed (Vector128<Single>* pClsVar2 = &_clsVar2)
{
- var result = Sse.CompareNotLessThanOrEqualScalar(
+ var result = Sse.CompareScalarNotLessThanOrEqual(
Sse.LoadVector128((Single*)(pClsVar1)),
Sse.LoadVector128((Single*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareNotLessThanOrEqualScalar(left, right);
+ var result = Sse.CompareScalarNotLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotLessThanOrEqualScalar(left, right);
+ var result = Sse.CompareScalarNotLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotLessThanOrEqualScalar(left, right);
+ var result = Sse.CompareScalarNotLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarSingle();
- var result = Sse.CompareNotLessThanOrEqualScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualSingle();
+ var result = Sse.CompareScalarNotLessThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualSingle();
fixed (Vector128<Single>* pFld1 = &test._fld1)
fixed (Vector128<Single>* pFld2 = &test._fld2)
{
- var result = Sse.CompareNotLessThanOrEqualScalar(
+ var result = Sse.CompareScalarNotLessThanOrEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareNotLessThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarNotLessThanOrEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareNotLessThanOrEqualScalar(
+ var result = Sse.CompareScalarNotLessThanOrEqual(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareNotLessThanOrEqualScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarNotLessThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse.CompareNotLessThanOrEqualScalar(
+ var result = Sse.CompareScalarNotLessThanOrEqual(
Sse.LoadVector128((Single*)(&test._fld1)),
Sse.LoadVector128((Single*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotLessThanOrEqualScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarNotLessThanOrEqual)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareOrderedScalarSingle()
+ private static void CompareScalarOrderedSingle()
{
- var test = new SimpleBinaryOpTest__CompareOrderedScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarOrderedSingle();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareOrderedScalarSingle
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarOrderedSingle
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareOrderedScalarSingle testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarOrderedSingle testClass)
{
- var result = Sse.CompareOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrdered(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareOrderedScalarSingle testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarOrderedSingle testClass)
{
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareOrderedScalar(
+ var result = Sse.CompareScalarOrdered(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Single, Single, Single> _dataTable;
- static SimpleBinaryOpTest__CompareOrderedScalarSingle()
+ static SimpleBinaryOpTest__CompareScalarOrderedSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public SimpleBinaryOpTest__CompareOrderedScalarSingle()
+ public SimpleBinaryOpTest__CompareScalarOrderedSingle()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareOrderedScalar(
+ var result = Sse.CompareScalarOrdered(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareOrderedScalar(
+ var result = Sse.CompareScalarOrdered(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareOrderedScalar(
+ var result = Sse.CompareScalarOrdered(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrdered), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrdered), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrdered), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareOrderedScalar(
+ var result = Sse.CompareScalarOrdered(
_clsVar1,
_clsVar2
);
fixed (Vector128<Single>* pClsVar1 = &_clsVar1)
fixed (Vector128<Single>* pClsVar2 = &_clsVar2)
{
- var result = Sse.CompareOrderedScalar(
+ var result = Sse.CompareScalarOrdered(
Sse.LoadVector128((Single*)(pClsVar1)),
Sse.LoadVector128((Single*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrdered(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrdered(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrdered(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareOrderedScalarSingle();
- var result = Sse.CompareOrderedScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarOrderedSingle();
+ var result = Sse.CompareScalarOrdered(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareOrderedScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarOrderedSingle();
fixed (Vector128<Single>* pFld1 = &test._fld1)
fixed (Vector128<Single>* pFld2 = &test._fld2)
{
- var result = Sse.CompareOrderedScalar(
+ var result = Sse.CompareScalarOrdered(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrdered(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareOrderedScalar(
+ var result = Sse.CompareScalarOrdered(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareOrderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarOrdered(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse.CompareOrderedScalar(
+ var result = Sse.CompareScalarOrdered(
Sse.LoadVector128((Single*)(&test._fld1)),
Sse.LoadVector128((Single*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareOrderedScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarOrdered)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareEqualOrderedScalarBoolean()
+ private static void CompareScalarOrderedEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarOrderedEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarOrderedEqualBoolean testClass)
{
- var result = Sse.CompareEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrderedEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Single, Single> _dataTable;
- static BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarOrderedEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarOrderedEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareEqualOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareEqualOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareEqualOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean();
- var result = Sse.CompareEqualOrderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedEqualBoolean();
+ var result = Sse.CompareScalarOrderedEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrderedEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareEqualOrderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarOrderedEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] == right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareEqualOrderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarOrderedEqual)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareGreaterThanOrderedScalarBoolean()
+ private static void CompareScalarOrderedGreaterThanBoolean()
{
- var test = new BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedGreaterThanBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarOrderedGreaterThanBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarOrderedGreaterThanBoolean testClass)
{
- var result = Sse.CompareGreaterThanOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrderedGreaterThan(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Single, Single> _dataTable;
- static BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarOrderedGreaterThanBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarOrderedGreaterThanBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareGreaterThanOrderedScalar(
+ var result = Sse.CompareScalarOrderedGreaterThan(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareGreaterThanOrderedScalar(
+ var result = Sse.CompareScalarOrderedGreaterThan(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareGreaterThanOrderedScalar(
+ var result = Sse.CompareScalarOrderedGreaterThan(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedGreaterThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedGreaterThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedGreaterThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareGreaterThanOrderedScalar(
+ var result = Sse.CompareScalarOrderedGreaterThan(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareGreaterThanOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedGreaterThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareGreaterThanOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedGreaterThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareGreaterThanOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedGreaterThan(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean();
- var result = Sse.CompareGreaterThanOrderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedGreaterThanBoolean();
+ var result = Sse.CompareScalarOrderedGreaterThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareGreaterThanOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrderedGreaterThan(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareGreaterThanOrderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarOrderedGreaterThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] > right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanOrderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarOrderedGreaterThan)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareGreaterThanOrEqualOrderedScalarBoolean()
+ private static void CompareScalarOrderedGreaterThanOrEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedGreaterThanOrEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarOrderedGreaterThanOrEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarOrderedGreaterThanOrEqualBoolean testClass)
{
- var result = Sse.CompareGreaterThanOrEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrderedGreaterThanOrEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Single, Single> _dataTable;
- static BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarOrderedGreaterThanOrEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarOrderedGreaterThanOrEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareGreaterThanOrEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedGreaterThanOrEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareGreaterThanOrEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedGreaterThanOrEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareGreaterThanOrEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedGreaterThanOrEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedGreaterThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedGreaterThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedGreaterThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareGreaterThanOrEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedGreaterThanOrEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareGreaterThanOrEqualOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedGreaterThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareGreaterThanOrEqualOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedGreaterThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareGreaterThanOrEqualOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedGreaterThanOrEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean();
- var result = Sse.CompareGreaterThanOrEqualOrderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedGreaterThanOrEqualBoolean();
+ var result = Sse.CompareScalarOrderedGreaterThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareGreaterThanOrEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrderedGreaterThanOrEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareGreaterThanOrEqualOrderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarOrderedGreaterThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] >= right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanOrEqualOrderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarOrderedGreaterThanOrEqual)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareLessThanOrderedScalarBoolean()
+ private static void CompareScalarOrderedLessThanBoolean()
{
- var test = new BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedLessThanBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarOrderedLessThanBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarOrderedLessThanBoolean testClass)
{
- var result = Sse.CompareLessThanOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrderedLessThan(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Single, Single> _dataTable;
- static BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarOrderedLessThanBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarOrderedLessThanBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareLessThanOrderedScalar(
+ var result = Sse.CompareScalarOrderedLessThan(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareLessThanOrderedScalar(
+ var result = Sse.CompareScalarOrderedLessThan(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareLessThanOrderedScalar(
+ var result = Sse.CompareScalarOrderedLessThan(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedLessThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedLessThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedLessThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareLessThanOrderedScalar(
+ var result = Sse.CompareScalarOrderedLessThan(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareLessThanOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedLessThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareLessThanOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedLessThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareLessThanOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedLessThan(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean();
- var result = Sse.CompareLessThanOrderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedLessThanBoolean();
+ var result = Sse.CompareScalarOrderedLessThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareLessThanOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrderedLessThan(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareLessThanOrderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarOrderedLessThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] < right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanOrderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarOrderedLessThan)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareLessThanOrEqualOrderedScalarBoolean()
+ private static void CompareScalarOrderedLessThanOrEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedLessThanOrEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarOrderedLessThanOrEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarOrderedLessThanOrEqualBoolean testClass)
{
- var result = Sse.CompareLessThanOrEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrderedLessThanOrEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Single, Single> _dataTable;
- static BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarOrderedLessThanOrEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarOrderedLessThanOrEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareLessThanOrEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedLessThanOrEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareLessThanOrEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedLessThanOrEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareLessThanOrEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedLessThanOrEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedLessThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedLessThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedLessThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareLessThanOrEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedLessThanOrEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareLessThanOrEqualOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedLessThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareLessThanOrEqualOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedLessThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareLessThanOrEqualOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedLessThanOrEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean();
- var result = Sse.CompareLessThanOrEqualOrderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedLessThanOrEqualBoolean();
+ var result = Sse.CompareScalarOrderedLessThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareLessThanOrEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrderedLessThanOrEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareLessThanOrEqualOrderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarOrderedLessThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] <= right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanOrEqualOrderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarOrderedLessThanOrEqual)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotEqualOrderedScalarBoolean()
+ private static void CompareScalarOrderedNotEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedNotEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarOrderedNotEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarOrderedNotEqualBoolean testClass)
{
- var result = Sse.CompareNotEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrderedNotEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Single, Single> _dataTable;
- static BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarOrderedNotEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarOrderedNotEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareNotEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedNotEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareNotEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedNotEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareNotEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedNotEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedNotEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedNotEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualOrderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarOrderedNotEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareNotEqualOrderedScalar(
+ var result = Sse.CompareScalarOrderedNotEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareNotEqualOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedNotEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotEqualOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedNotEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotEqualOrderedScalar(left, right);
+ var result = Sse.CompareScalarOrderedNotEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean();
- var result = Sse.CompareNotEqualOrderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedNotEqualBoolean();
+ var result = Sse.CompareScalarOrderedNotEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareNotEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarOrderedNotEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareNotEqualOrderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarOrderedNotEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] != right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotEqualOrderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarOrderedNotEqual)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareUnorderedScalarSingle()
+ private static void CompareScalarUnorderedSingle()
{
- var test = new SimpleBinaryOpTest__CompareUnorderedScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarUnorderedSingle();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareUnorderedScalarSingle
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarUnorderedSingle
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareUnorderedScalarSingle testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarUnorderedSingle testClass)
{
- var result = Sse.CompareUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnordered(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareUnorderedScalarSingle testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarUnorderedSingle testClass)
{
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareUnorderedScalar(
+ var result = Sse.CompareScalarUnordered(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Single, Single, Single> _dataTable;
- static SimpleBinaryOpTest__CompareUnorderedScalarSingle()
+ static SimpleBinaryOpTest__CompareScalarUnorderedSingle()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public SimpleBinaryOpTest__CompareUnorderedScalarSingle()
+ public SimpleBinaryOpTest__CompareScalarUnorderedSingle()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareUnorderedScalar(
+ var result = Sse.CompareScalarUnordered(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareUnorderedScalar(
+ var result = Sse.CompareScalarUnordered(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareUnorderedScalar(
+ var result = Sse.CompareScalarUnordered(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnordered), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnordered), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnordered), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareUnorderedScalar(
+ var result = Sse.CompareScalarUnordered(
_clsVar1,
_clsVar2
);
fixed (Vector128<Single>* pClsVar1 = &_clsVar1)
fixed (Vector128<Single>* pClsVar2 = &_clsVar2)
{
- var result = Sse.CompareUnorderedScalar(
+ var result = Sse.CompareScalarUnordered(
Sse.LoadVector128((Single*)(pClsVar1)),
Sse.LoadVector128((Single*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnordered(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnordered(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnordered(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareUnorderedScalarSingle();
- var result = Sse.CompareUnorderedScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarUnorderedSingle();
+ var result = Sse.CompareScalarUnordered(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareUnorderedScalarSingle();
+ var test = new SimpleBinaryOpTest__CompareScalarUnorderedSingle();
fixed (Vector128<Single>* pFld1 = &test._fld1)
fixed (Vector128<Single>* pFld2 = &test._fld2)
{
- var result = Sse.CompareUnorderedScalar(
+ var result = Sse.CompareScalarUnordered(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnordered(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Single>* pFld1 = &_fld1)
fixed (Vector128<Single>* pFld2 = &_fld2)
{
- var result = Sse.CompareUnorderedScalar(
+ var result = Sse.CompareScalarUnordered(
Sse.LoadVector128((Single*)(pFld1)),
Sse.LoadVector128((Single*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarUnordered(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse.CompareUnorderedScalar(
+ var result = Sse.CompareScalarUnordered(
Sse.LoadVector128((Single*)(&test._fld1)),
Sse.LoadVector128((Single*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareUnorderedScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarUnordered)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareEqualUnorderedScalarBoolean()
+ private static void CompareScalarUnorderedEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarUnorderedEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarUnorderedEqualBoolean testClass)
{
- var result = Sse.CompareEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnorderedEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Single, Single> _dataTable;
- static BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarUnorderedEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarUnorderedEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareEqualUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareEqualUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareEqualUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean();
- var result = Sse.CompareEqualUnorderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedEqualBoolean();
+ var result = Sse.CompareScalarUnorderedEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnorderedEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareEqualUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarUnorderedEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] == right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareEqualUnorderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarUnorderedEqual)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareGreaterThanUnorderedScalarBoolean()
+ private static void CompareScalarUnorderedGreaterThanBoolean()
{
- var test = new BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanBoolean testClass)
{
- var result = Sse.CompareGreaterThanUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnorderedGreaterThan(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Single, Single> _dataTable;
- static BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareGreaterThanUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedGreaterThan(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareGreaterThanUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedGreaterThan(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareGreaterThanUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedGreaterThan(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedGreaterThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedGreaterThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedGreaterThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareGreaterThanUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedGreaterThan(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareGreaterThanUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedGreaterThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareGreaterThanUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedGreaterThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareGreaterThanUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedGreaterThan(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean();
- var result = Sse.CompareGreaterThanUnorderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanBoolean();
+ var result = Sse.CompareScalarUnorderedGreaterThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareGreaterThanUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnorderedGreaterThan(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareGreaterThanUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarUnorderedGreaterThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] > right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanUnorderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarUnorderedGreaterThan)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareGreaterThanOrEqualUnorderedScalarBoolean()
+ private static void CompareScalarUnorderedGreaterThanOrEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanOrEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanOrEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanOrEqualBoolean testClass)
{
- var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnorderedGreaterThanOrEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Single, Single> _dataTable;
- static BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanOrEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanOrEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedGreaterThanOrEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedGreaterThanOrEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedGreaterThanOrEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedGreaterThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedGreaterThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedGreaterThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedGreaterThanOrEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedGreaterThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedGreaterThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedGreaterThanOrEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean();
- var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanOrEqualBoolean();
+ var result = Sse.CompareScalarUnorderedGreaterThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnorderedGreaterThanOrEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarUnorderedGreaterThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] >= right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanOrEqualUnorderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarUnorderedGreaterThanOrEqual)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareLessThanUnorderedScalarBoolean()
+ private static void CompareScalarUnorderedLessThanBoolean()
{
- var test = new BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedLessThanBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarUnorderedLessThanBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarUnorderedLessThanBoolean testClass)
{
- var result = Sse.CompareLessThanUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnorderedLessThan(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Single, Single> _dataTable;
- static BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarUnorderedLessThanBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarUnorderedLessThanBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareLessThanUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedLessThan(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareLessThanUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedLessThan(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareLessThanUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedLessThan(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedLessThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedLessThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedLessThan), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareLessThanUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedLessThan(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareLessThanUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedLessThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareLessThanUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedLessThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareLessThanUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedLessThan(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean();
- var result = Sse.CompareLessThanUnorderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedLessThanBoolean();
+ var result = Sse.CompareScalarUnorderedLessThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareLessThanUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnorderedLessThan(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareLessThanUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarUnorderedLessThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] < right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanUnorderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarUnorderedLessThan)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareLessThanOrEqualUnorderedScalarBoolean()
+ private static void CompareScalarUnorderedLessThanOrEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedLessThanOrEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarUnorderedLessThanOrEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarUnorderedLessThanOrEqualBoolean testClass)
{
- var result = Sse.CompareLessThanOrEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnorderedLessThanOrEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Single, Single> _dataTable;
- static BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarUnorderedLessThanOrEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarUnorderedLessThanOrEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareLessThanOrEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedLessThanOrEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareLessThanOrEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedLessThanOrEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareLessThanOrEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedLessThanOrEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedLessThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedLessThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedLessThanOrEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareLessThanOrEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedLessThanOrEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareLessThanOrEqualUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedLessThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareLessThanOrEqualUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedLessThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareLessThanOrEqualUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedLessThanOrEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean();
- var result = Sse.CompareLessThanOrEqualUnorderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedLessThanOrEqualBoolean();
+ var result = Sse.CompareScalarUnorderedLessThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareLessThanOrEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnorderedLessThanOrEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareLessThanOrEqualUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarUnorderedLessThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] <= right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanOrEqualUnorderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarUnorderedLessThanOrEqual)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotEqualUnorderedScalarBoolean()
+ private static void CompareScalarUnorderedNotEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedNotEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarUnorderedNotEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarUnorderedNotEqualBoolean testClass)
{
- var result = Sse.CompareNotEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnorderedNotEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Single, Single> _dataTable;
- static BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarUnorderedNotEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar1), ref Unsafe.As<Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Single>, byte>(ref _clsVar2), ref Unsafe.As<Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Single>>());
}
- public BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarUnorderedNotEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse.CompareNotEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedNotEqual(
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse.CompareNotEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedNotEqual(
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse.CompareNotEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedNotEqual(
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedNotEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedNotEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualUnorderedScalar), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
+ var result = typeof(Sse).GetMethod(nameof(Sse.CompareScalarUnorderedNotEqual), new Type[] { typeof(Vector128<Single>), typeof(Vector128<Single>) })
.Invoke(null, new object[] {
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse.CompareNotEqualUnorderedScalar(
+ var result = Sse.CompareScalarUnorderedNotEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Single>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
- var result = Sse.CompareNotEqualUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedNotEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotEqualUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedNotEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr));
- var result = Sse.CompareNotEqualUnorderedScalar(left, right);
+ var result = Sse.CompareScalarUnorderedNotEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean();
- var result = Sse.CompareNotEqualUnorderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedNotEqualBoolean();
+ var result = Sse.CompareScalarUnorderedNotEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse.CompareNotEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse.CompareScalarUnorderedNotEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse.CompareNotEqualUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse.CompareScalarUnorderedNotEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] != right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotEqualUnorderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareScalarUnorderedNotEqual)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
["And.Single"] = AndSingle,
["AndNot.Single"] = AndNotSingle,
["CompareEqual.Single"] = CompareEqualSingle,
- ["CompareEqualScalar.Single"] = CompareEqualScalarSingle,
- ["CompareEqualOrderedScalar.Boolean"] = CompareEqualOrderedScalarBoolean,
- ["CompareEqualUnorderedScalar.Boolean"] = CompareEqualUnorderedScalarBoolean,
+ ["CompareScalarEqual.Single"] = CompareScalarEqualSingle,
+ ["CompareScalarOrderedEqual.Boolean"] = CompareScalarOrderedEqualBoolean,
+ ["CompareScalarUnorderedEqual.Boolean"] = CompareScalarUnorderedEqualBoolean,
["CompareGreaterThan.Single"] = CompareGreaterThanSingle,
- ["CompareGreaterThanScalar.Single"] = CompareGreaterThanScalarSingle,
- ["CompareGreaterThanOrderedScalar.Boolean"] = CompareGreaterThanOrderedScalarBoolean,
- ["CompareGreaterThanUnorderedScalar.Boolean"] = CompareGreaterThanUnorderedScalarBoolean,
+ ["CompareScalarGreaterThan.Single"] = CompareScalarGreaterThanSingle,
+ ["CompareScalarOrderedGreaterThan.Boolean"] = CompareScalarOrderedGreaterThanBoolean,
+ ["CompareScalarUnorderedGreaterThan.Boolean"] = CompareScalarUnorderedGreaterThanBoolean,
["CompareGreaterThanOrEqual.Single"] = CompareGreaterThanOrEqualSingle,
- ["CompareGreaterThanOrEqualScalar.Single"] = CompareGreaterThanOrEqualScalarSingle,
- ["CompareGreaterThanOrEqualOrderedScalar.Boolean"] = CompareGreaterThanOrEqualOrderedScalarBoolean,
- ["CompareGreaterThanOrEqualUnorderedScalar.Boolean"] = CompareGreaterThanOrEqualUnorderedScalarBoolean,
+ ["CompareScalarGreaterThanOrEqual.Single"] = CompareScalarGreaterThanOrEqualSingle,
+ ["CompareScalarOrderedGreaterThanOrEqual.Boolean"] = CompareScalarOrderedGreaterThanOrEqualBoolean,
+ ["CompareScalarUnorderedGreaterThanOrEqual.Boolean"] = CompareScalarUnorderedGreaterThanOrEqualBoolean,
["CompareLessThan.Single"] = CompareLessThanSingle,
- ["CompareLessThanScalar.Single"] = CompareLessThanScalarSingle,
- ["CompareLessThanOrderedScalar.Boolean"] = CompareLessThanOrderedScalarBoolean,
- ["CompareLessThanUnorderedScalar.Boolean"] = CompareLessThanUnorderedScalarBoolean,
+ ["CompareScalarLessThan.Single"] = CompareScalarLessThanSingle,
+ ["CompareScalarOrderedLessThan.Boolean"] = CompareScalarOrderedLessThanBoolean,
+ ["CompareScalarUnorderedLessThan.Boolean"] = CompareScalarUnorderedLessThanBoolean,
["CompareLessThanOrEqual.Single"] = CompareLessThanOrEqualSingle,
- ["CompareLessThanOrEqualScalar.Single"] = CompareLessThanOrEqualScalarSingle,
- ["CompareLessThanOrEqualOrderedScalar.Boolean"] = CompareLessThanOrEqualOrderedScalarBoolean,
- ["CompareLessThanOrEqualUnorderedScalar.Boolean"] = CompareLessThanOrEqualUnorderedScalarBoolean,
+ ["CompareScalarLessThanOrEqual.Single"] = CompareScalarLessThanOrEqualSingle,
+ ["CompareScalarOrderedLessThanOrEqual.Boolean"] = CompareScalarOrderedLessThanOrEqualBoolean,
+ ["CompareScalarUnorderedLessThanOrEqual.Boolean"] = CompareScalarUnorderedLessThanOrEqualBoolean,
["CompareNotEqual.Single"] = CompareNotEqualSingle,
- ["CompareNotEqualScalar.Single"] = CompareNotEqualScalarSingle,
- ["CompareNotEqualOrderedScalar.Boolean"] = CompareNotEqualOrderedScalarBoolean,
- ["CompareNotEqualUnorderedScalar.Boolean"] = CompareNotEqualUnorderedScalarBoolean,
+ ["CompareScalarNotEqual.Single"] = CompareScalarNotEqualSingle,
+ ["CompareScalarOrderedNotEqual.Boolean"] = CompareScalarOrderedNotEqualBoolean,
+ ["CompareScalarUnorderedNotEqual.Boolean"] = CompareScalarUnorderedNotEqualBoolean,
["CompareNotGreaterThan.Single"] = CompareNotGreaterThanSingle,
- ["CompareNotGreaterThanScalar.Single"] = CompareNotGreaterThanScalarSingle,
+ ["CompareScalarNotGreaterThan.Single"] = CompareScalarNotGreaterThanSingle,
["CompareNotGreaterThanOrEqual.Single"] = CompareNotGreaterThanOrEqualSingle,
- ["CompareNotGreaterThanOrEqualScalar.Single"] = CompareNotGreaterThanOrEqualScalarSingle,
+ ["CompareScalarNotGreaterThanOrEqual.Single"] = CompareScalarNotGreaterThanOrEqualSingle,
["CompareNotLessThan.Single"] = CompareNotLessThanSingle,
- ["CompareNotLessThanScalar.Single"] = CompareNotLessThanScalarSingle,
+ ["CompareScalarNotLessThan.Single"] = CompareScalarNotLessThanSingle,
["CompareNotLessThanOrEqual.Single"] = CompareNotLessThanOrEqualSingle,
- ["CompareNotLessThanOrEqualScalar.Single"] = CompareNotLessThanOrEqualScalarSingle,
+ ["CompareScalarNotLessThanOrEqual.Single"] = CompareScalarNotLessThanOrEqualSingle,
["CompareOrdered.Single"] = CompareOrderedSingle,
- ["CompareOrderedScalar.Single"] = CompareOrderedScalarSingle,
+ ["CompareScalarOrdered.Single"] = CompareScalarOrderedSingle,
["CompareUnordered.Single"] = CompareUnorderedSingle,
- ["CompareUnorderedScalar.Single"] = CompareUnorderedScalarSingle,
+ ["CompareScalarUnordered.Single"] = CompareScalarUnorderedSingle,
["ConvertScalarToVector128Single.Single"] = ConvertScalarToVector128SingleSingle,
["Divide.Single"] = DivideSingle,
["DivideScalar.Single"] = DivideScalarSingle,
<Compile Include="And.Single.cs" />
<Compile Include="AndNot.Single.cs" />
<Compile Include="CompareEqual.Single.cs" />
- <Compile Include="CompareEqualScalar.Single.cs" />
- <Compile Include="CompareEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareEqualUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarEqual.Single.cs" />
+ <Compile Include="CompareScalarOrderedEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedEqual.Boolean.cs" />
<Compile Include="CompareGreaterThan.Single.cs" />
- <Compile Include="CompareGreaterThanScalar.Single.cs" />
- <Compile Include="CompareGreaterThanOrderedScalar.Boolean.cs" />
- <Compile Include="CompareGreaterThanUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarGreaterThan.Single.cs" />
+ <Compile Include="CompareScalarOrderedGreaterThan.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedGreaterThan.Boolean.cs" />
<Compile Include="CompareGreaterThanOrEqual.Single.cs" />
- <Compile Include="CompareGreaterThanOrEqualScalar.Single.cs" />
- <Compile Include="CompareGreaterThanOrEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarGreaterThanOrEqual.Single.cs" />
+ <Compile Include="CompareScalarOrderedGreaterThanOrEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedGreaterThanOrEqual.Boolean.cs" />
<Compile Include="CompareLessThan.Single.cs" />
- <Compile Include="CompareLessThanScalar.Single.cs" />
- <Compile Include="CompareLessThanOrderedScalar.Boolean.cs" />
- <Compile Include="CompareLessThanUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarLessThan.Single.cs" />
+ <Compile Include="CompareScalarOrderedLessThan.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedLessThan.Boolean.cs" />
<Compile Include="CompareLessThanOrEqual.Single.cs" />
- <Compile Include="CompareLessThanOrEqualScalar.Single.cs" />
- <Compile Include="CompareLessThanOrEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareLessThanOrEqualUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarLessThanOrEqual.Single.cs" />
+ <Compile Include="CompareScalarOrderedLessThanOrEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedLessThanOrEqual.Boolean.cs" />
<Compile Include="CompareNotEqual.Single.cs" />
- <Compile Include="CompareNotEqualScalar.Single.cs" />
- <Compile Include="CompareNotEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareNotEqualUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarNotEqual.Single.cs" />
+ <Compile Include="CompareScalarOrderedNotEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedNotEqual.Boolean.cs" />
<Compile Include="CompareNotGreaterThan.Single.cs" />
- <Compile Include="CompareNotGreaterThanScalar.Single.cs" />
+ <Compile Include="CompareScalarNotGreaterThan.Single.cs" />
<Compile Include="CompareNotGreaterThanOrEqual.Single.cs" />
- <Compile Include="CompareNotGreaterThanOrEqualScalar.Single.cs" />
+ <Compile Include="CompareScalarNotGreaterThanOrEqual.Single.cs" />
<Compile Include="CompareNotLessThan.Single.cs" />
- <Compile Include="CompareNotLessThanScalar.Single.cs" />
+ <Compile Include="CompareScalarNotLessThan.Single.cs" />
<Compile Include="CompareNotLessThanOrEqual.Single.cs" />
- <Compile Include="CompareNotLessThanOrEqualScalar.Single.cs" />
+ <Compile Include="CompareScalarNotLessThanOrEqual.Single.cs" />
<Compile Include="CompareOrdered.Single.cs" />
- <Compile Include="CompareOrderedScalar.Single.cs" />
+ <Compile Include="CompareScalarOrdered.Single.cs" />
<Compile Include="CompareUnordered.Single.cs" />
- <Compile Include="CompareUnorderedScalar.Single.cs" />
+ <Compile Include="CompareScalarUnordered.Single.cs" />
<Compile Include="ConvertScalarToVector128Single.Single.cs" />
<Compile Include="Divide.Single.cs" />
<Compile Include="DivideScalar.Single.cs" />
<Compile Include="And.Single.cs" />
<Compile Include="AndNot.Single.cs" />
<Compile Include="CompareEqual.Single.cs" />
- <Compile Include="CompareEqualScalar.Single.cs" />
- <Compile Include="CompareEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareEqualUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarEqual.Single.cs" />
+ <Compile Include="CompareScalarOrderedEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedEqual.Boolean.cs" />
<Compile Include="CompareGreaterThan.Single.cs" />
- <Compile Include="CompareGreaterThanScalar.Single.cs" />
- <Compile Include="CompareGreaterThanOrderedScalar.Boolean.cs" />
- <Compile Include="CompareGreaterThanUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarGreaterThan.Single.cs" />
+ <Compile Include="CompareScalarOrderedGreaterThan.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedGreaterThan.Boolean.cs" />
<Compile Include="CompareGreaterThanOrEqual.Single.cs" />
- <Compile Include="CompareGreaterThanOrEqualScalar.Single.cs" />
- <Compile Include="CompareGreaterThanOrEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarGreaterThanOrEqual.Single.cs" />
+ <Compile Include="CompareScalarOrderedGreaterThanOrEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedGreaterThanOrEqual.Boolean.cs" />
<Compile Include="CompareLessThan.Single.cs" />
- <Compile Include="CompareLessThanScalar.Single.cs" />
- <Compile Include="CompareLessThanOrderedScalar.Boolean.cs" />
- <Compile Include="CompareLessThanUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarLessThan.Single.cs" />
+ <Compile Include="CompareScalarOrderedLessThan.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedLessThan.Boolean.cs" />
<Compile Include="CompareLessThanOrEqual.Single.cs" />
- <Compile Include="CompareLessThanOrEqualScalar.Single.cs" />
- <Compile Include="CompareLessThanOrEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareLessThanOrEqualUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarLessThanOrEqual.Single.cs" />
+ <Compile Include="CompareScalarOrderedLessThanOrEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedLessThanOrEqual.Boolean.cs" />
<Compile Include="CompareNotEqual.Single.cs" />
- <Compile Include="CompareNotEqualScalar.Single.cs" />
- <Compile Include="CompareNotEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareNotEqualUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarNotEqual.Single.cs" />
+ <Compile Include="CompareScalarOrderedNotEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedNotEqual.Boolean.cs" />
<Compile Include="CompareNotGreaterThan.Single.cs" />
- <Compile Include="CompareNotGreaterThanScalar.Single.cs" />
+ <Compile Include="CompareScalarNotGreaterThan.Single.cs" />
<Compile Include="CompareNotGreaterThanOrEqual.Single.cs" />
- <Compile Include="CompareNotGreaterThanOrEqualScalar.Single.cs" />
+ <Compile Include="CompareScalarNotGreaterThanOrEqual.Single.cs" />
<Compile Include="CompareNotLessThan.Single.cs" />
- <Compile Include="CompareNotLessThanScalar.Single.cs" />
+ <Compile Include="CompareScalarNotLessThan.Single.cs" />
<Compile Include="CompareNotLessThanOrEqual.Single.cs" />
- <Compile Include="CompareNotLessThanOrEqualScalar.Single.cs" />
+ <Compile Include="CompareScalarNotLessThanOrEqual.Single.cs" />
<Compile Include="CompareOrdered.Single.cs" />
- <Compile Include="CompareOrderedScalar.Single.cs" />
+ <Compile Include="CompareScalarOrdered.Single.cs" />
<Compile Include="CompareUnordered.Single.cs" />
- <Compile Include="CompareUnorderedScalar.Single.cs" />
+ <Compile Include="CompareScalarUnordered.Single.cs" />
<Compile Include="ConvertScalarToVector128Single.Single.cs" />
<Compile Include="Divide.Single.cs" />
<Compile Include="DivideScalar.Single.cs" />
{
public static partial class Program
{
- private static void CompareEqualScalarDouble()
+ private static void CompareScalarEqualDouble()
{
- var test = new SimpleBinaryOpTest__CompareEqualScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarEqualDouble();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareEqualScalarDouble
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarEqualDouble
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareEqualScalarDouble testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarEqualDouble testClass)
{
- var result = Sse2.CompareEqualScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareEqualScalarDouble testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarEqualDouble testClass)
{
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareEqualScalar(
+ var result = Sse2.CompareScalarEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Double, Double, Double> _dataTable;
- static SimpleBinaryOpTest__CompareEqualScalarDouble()
+ static SimpleBinaryOpTest__CompareScalarEqualDouble()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public SimpleBinaryOpTest__CompareEqualScalarDouble()
+ public SimpleBinaryOpTest__CompareScalarEqualDouble()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareEqualScalar(
+ var result = Sse2.CompareScalarEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareEqualScalar(
+ var result = Sse2.CompareScalarEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareEqualScalar(
+ var result = Sse2.CompareScalarEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareEqualScalar(
+ var result = Sse2.CompareScalarEqual(
_clsVar1,
_clsVar2
);
fixed (Vector128<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
- var result = Sse2.CompareEqualScalar(
+ var result = Sse2.CompareScalarEqual(
Sse2.LoadVector128((Double*)(pClsVar1)),
Sse2.LoadVector128((Double*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareEqualScalar(left, right);
+ var result = Sse2.CompareScalarEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareEqualScalar(left, right);
+ var result = Sse2.CompareScalarEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareEqualScalar(left, right);
+ var result = Sse2.CompareScalarEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareEqualScalarDouble();
- var result = Sse2.CompareEqualScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarEqualDouble();
+ var result = Sse2.CompareScalarEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareEqualScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarEqualDouble();
fixed (Vector128<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
- var result = Sse2.CompareEqualScalar(
+ var result = Sse2.CompareScalarEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareEqualScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareEqualScalar(
+ var result = Sse2.CompareScalarEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareEqualScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse2.CompareEqualScalar(
+ var result = Sse2.CompareScalarEqual(
Sse2.LoadVector128((Double*)(&test._fld1)),
Sse2.LoadVector128((Double*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqualScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarEqual)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareGreaterThanScalarDouble()
+ private static void CompareScalarGreaterThanDouble()
{
- var test = new SimpleBinaryOpTest__CompareGreaterThanScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarGreaterThanDouble();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareGreaterThanScalarDouble
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarGreaterThanDouble
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareGreaterThanScalarDouble testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarGreaterThanDouble testClass)
{
- var result = Sse2.CompareGreaterThanScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarGreaterThan(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareGreaterThanScalarDouble testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarGreaterThanDouble testClass)
{
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareGreaterThanScalar(
+ var result = Sse2.CompareScalarGreaterThan(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Double, Double, Double> _dataTable;
- static SimpleBinaryOpTest__CompareGreaterThanScalarDouble()
+ static SimpleBinaryOpTest__CompareScalarGreaterThanDouble()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public SimpleBinaryOpTest__CompareGreaterThanScalarDouble()
+ public SimpleBinaryOpTest__CompareScalarGreaterThanDouble()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareGreaterThanScalar(
+ var result = Sse2.CompareScalarGreaterThan(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareGreaterThanScalar(
+ var result = Sse2.CompareScalarGreaterThan(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareGreaterThanScalar(
+ var result = Sse2.CompareScalarGreaterThan(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarGreaterThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarGreaterThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarGreaterThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareGreaterThanScalar(
+ var result = Sse2.CompareScalarGreaterThan(
_clsVar1,
_clsVar2
);
fixed (Vector128<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
- var result = Sse2.CompareGreaterThanScalar(
+ var result = Sse2.CompareScalarGreaterThan(
Sse2.LoadVector128((Double*)(pClsVar1)),
Sse2.LoadVector128((Double*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareGreaterThanScalar(left, right);
+ var result = Sse2.CompareScalarGreaterThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareGreaterThanScalar(left, right);
+ var result = Sse2.CompareScalarGreaterThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareGreaterThanScalar(left, right);
+ var result = Sse2.CompareScalarGreaterThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareGreaterThanScalarDouble();
- var result = Sse2.CompareGreaterThanScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarGreaterThanDouble();
+ var result = Sse2.CompareScalarGreaterThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareGreaterThanScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarGreaterThanDouble();
fixed (Vector128<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
- var result = Sse2.CompareGreaterThanScalar(
+ var result = Sse2.CompareScalarGreaterThan(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareGreaterThanScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarGreaterThan(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareGreaterThanScalar(
+ var result = Sse2.CompareScalarGreaterThan(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareGreaterThanScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarGreaterThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse2.CompareGreaterThanScalar(
+ var result = Sse2.CompareScalarGreaterThan(
Sse2.LoadVector128((Double*)(&test._fld1)),
Sse2.LoadVector128((Double*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarGreaterThan)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareGreaterThanOrEqualScalarDouble()
+ private static void CompareScalarGreaterThanOrEqualDouble()
{
- var test = new SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualDouble();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarDouble
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualDouble
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarDouble testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualDouble testClass)
{
- var result = Sse2.CompareGreaterThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarGreaterThanOrEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarDouble testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualDouble testClass)
{
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Double, Double, Double> _dataTable;
- static SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarDouble()
+ static SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualDouble()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarDouble()
+ public SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualDouble()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarGreaterThanOrEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarGreaterThanOrEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarGreaterThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarGreaterThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarGreaterThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarGreaterThanOrEqual(
_clsVar1,
_clsVar2
);
fixed (Vector128<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
- var result = Sse2.CompareGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(pClsVar1)),
Sse2.LoadVector128((Double*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareGreaterThanOrEqualScalar(left, right);
+ var result = Sse2.CompareScalarGreaterThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareGreaterThanOrEqualScalar(left, right);
+ var result = Sse2.CompareScalarGreaterThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareGreaterThanOrEqualScalar(left, right);
+ var result = Sse2.CompareScalarGreaterThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarDouble();
- var result = Sse2.CompareGreaterThanOrEqualScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualDouble();
+ var result = Sse2.CompareScalarGreaterThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarGreaterThanOrEqualDouble();
fixed (Vector128<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
- var result = Sse2.CompareGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareGreaterThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarGreaterThanOrEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareGreaterThanOrEqualScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarGreaterThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse2.CompareGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(&test._fld1)),
Sse2.LoadVector128((Double*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanOrEqualScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarGreaterThanOrEqual)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareLessThanScalarDouble()
+ private static void CompareScalarLessThanDouble()
{
- var test = new SimpleBinaryOpTest__CompareLessThanScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarLessThanDouble();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareLessThanScalarDouble
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarLessThanDouble
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareLessThanScalarDouble testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarLessThanDouble testClass)
{
- var result = Sse2.CompareLessThanScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarLessThan(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareLessThanScalarDouble testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarLessThanDouble testClass)
{
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareLessThanScalar(
+ var result = Sse2.CompareScalarLessThan(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Double, Double, Double> _dataTable;
- static SimpleBinaryOpTest__CompareLessThanScalarDouble()
+ static SimpleBinaryOpTest__CompareScalarLessThanDouble()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public SimpleBinaryOpTest__CompareLessThanScalarDouble()
+ public SimpleBinaryOpTest__CompareScalarLessThanDouble()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareLessThanScalar(
+ var result = Sse2.CompareScalarLessThan(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareLessThanScalar(
+ var result = Sse2.CompareScalarLessThan(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareLessThanScalar(
+ var result = Sse2.CompareScalarLessThan(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarLessThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarLessThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarLessThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareLessThanScalar(
+ var result = Sse2.CompareScalarLessThan(
_clsVar1,
_clsVar2
);
fixed (Vector128<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
- var result = Sse2.CompareLessThanScalar(
+ var result = Sse2.CompareScalarLessThan(
Sse2.LoadVector128((Double*)(pClsVar1)),
Sse2.LoadVector128((Double*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareLessThanScalar(left, right);
+ var result = Sse2.CompareScalarLessThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareLessThanScalar(left, right);
+ var result = Sse2.CompareScalarLessThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareLessThanScalar(left, right);
+ var result = Sse2.CompareScalarLessThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareLessThanScalarDouble();
- var result = Sse2.CompareLessThanScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarLessThanDouble();
+ var result = Sse2.CompareScalarLessThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareLessThanScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarLessThanDouble();
fixed (Vector128<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
- var result = Sse2.CompareLessThanScalar(
+ var result = Sse2.CompareScalarLessThan(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareLessThanScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarLessThan(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareLessThanScalar(
+ var result = Sse2.CompareScalarLessThan(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareLessThanScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarLessThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse2.CompareLessThanScalar(
+ var result = Sse2.CompareScalarLessThan(
Sse2.LoadVector128((Double*)(&test._fld1)),
Sse2.LoadVector128((Double*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarLessThan)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareLessThanOrEqualScalarDouble()
+ private static void CompareScalarLessThanOrEqualDouble()
{
- var test = new SimpleBinaryOpTest__CompareLessThanOrEqualScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarLessThanOrEqualDouble();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareLessThanOrEqualScalarDouble
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarLessThanOrEqualDouble
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareLessThanOrEqualScalarDouble testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarLessThanOrEqualDouble testClass)
{
- var result = Sse2.CompareLessThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarLessThanOrEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareLessThanOrEqualScalarDouble testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarLessThanOrEqualDouble testClass)
{
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarLessThanOrEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Double, Double, Double> _dataTable;
- static SimpleBinaryOpTest__CompareLessThanOrEqualScalarDouble()
+ static SimpleBinaryOpTest__CompareScalarLessThanOrEqualDouble()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public SimpleBinaryOpTest__CompareLessThanOrEqualScalarDouble()
+ public SimpleBinaryOpTest__CompareScalarLessThanOrEqualDouble()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarLessThanOrEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarLessThanOrEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarLessThanOrEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarLessThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarLessThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarLessThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarLessThanOrEqual(
_clsVar1,
_clsVar2
);
fixed (Vector128<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
- var result = Sse2.CompareLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarLessThanOrEqual(
Sse2.LoadVector128((Double*)(pClsVar1)),
Sse2.LoadVector128((Double*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareLessThanOrEqualScalar(left, right);
+ var result = Sse2.CompareScalarLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareLessThanOrEqualScalar(left, right);
+ var result = Sse2.CompareScalarLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareLessThanOrEqualScalar(left, right);
+ var result = Sse2.CompareScalarLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareLessThanOrEqualScalarDouble();
- var result = Sse2.CompareLessThanOrEqualScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarLessThanOrEqualDouble();
+ var result = Sse2.CompareScalarLessThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareLessThanOrEqualScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarLessThanOrEqualDouble();
fixed (Vector128<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
- var result = Sse2.CompareLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarLessThanOrEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareLessThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarLessThanOrEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarLessThanOrEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareLessThanOrEqualScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarLessThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse2.CompareLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarLessThanOrEqual(
Sse2.LoadVector128((Double*)(&test._fld1)),
Sse2.LoadVector128((Double*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanOrEqualScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarLessThanOrEqual)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotEqualScalarDouble()
+ private static void CompareScalarNotEqualDouble()
{
- var test = new SimpleBinaryOpTest__CompareNotEqualScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarNotEqualDouble();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareNotEqualScalarDouble
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarNotEqualDouble
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareNotEqualScalarDouble testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarNotEqualDouble testClass)
{
- var result = Sse2.CompareNotEqualScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarNotEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareNotEqualScalarDouble testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarNotEqualDouble testClass)
{
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareNotEqualScalar(
+ var result = Sse2.CompareScalarNotEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Double, Double, Double> _dataTable;
- static SimpleBinaryOpTest__CompareNotEqualScalarDouble()
+ static SimpleBinaryOpTest__CompareScalarNotEqualDouble()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public SimpleBinaryOpTest__CompareNotEqualScalarDouble()
+ public SimpleBinaryOpTest__CompareScalarNotEqualDouble()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareNotEqualScalar(
+ var result = Sse2.CompareScalarNotEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareNotEqualScalar(
+ var result = Sse2.CompareScalarNotEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareNotEqualScalar(
+ var result = Sse2.CompareScalarNotEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareNotEqualScalar(
+ var result = Sse2.CompareScalarNotEqual(
_clsVar1,
_clsVar2
);
fixed (Vector128<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
- var result = Sse2.CompareNotEqualScalar(
+ var result = Sse2.CompareScalarNotEqual(
Sse2.LoadVector128((Double*)(pClsVar1)),
Sse2.LoadVector128((Double*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareNotEqualScalar(left, right);
+ var result = Sse2.CompareScalarNotEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotEqualScalar(left, right);
+ var result = Sse2.CompareScalarNotEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotEqualScalar(left, right);
+ var result = Sse2.CompareScalarNotEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareNotEqualScalarDouble();
- var result = Sse2.CompareNotEqualScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarNotEqualDouble();
+ var result = Sse2.CompareScalarNotEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareNotEqualScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarNotEqualDouble();
fixed (Vector128<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
- var result = Sse2.CompareNotEqualScalar(
+ var result = Sse2.CompareScalarNotEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareNotEqualScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarNotEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareNotEqualScalar(
+ var result = Sse2.CompareScalarNotEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareNotEqualScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarNotEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse2.CompareNotEqualScalar(
+ var result = Sse2.CompareScalarNotEqual(
Sse2.LoadVector128((Double*)(&test._fld1)),
Sse2.LoadVector128((Double*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotEqualScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarNotEqual)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotGreaterThanScalarDouble()
+ private static void CompareScalarNotGreaterThanDouble()
{
- var test = new SimpleBinaryOpTest__CompareNotGreaterThanScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarNotGreaterThanDouble();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareNotGreaterThanScalarDouble
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarNotGreaterThanDouble
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareNotGreaterThanScalarDouble testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarNotGreaterThanDouble testClass)
{
- var result = Sse2.CompareNotGreaterThanScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarNotGreaterThan(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareNotGreaterThanScalarDouble testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarNotGreaterThanDouble testClass)
{
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareNotGreaterThanScalar(
+ var result = Sse2.CompareScalarNotGreaterThan(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Double, Double, Double> _dataTable;
- static SimpleBinaryOpTest__CompareNotGreaterThanScalarDouble()
+ static SimpleBinaryOpTest__CompareScalarNotGreaterThanDouble()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public SimpleBinaryOpTest__CompareNotGreaterThanScalarDouble()
+ public SimpleBinaryOpTest__CompareScalarNotGreaterThanDouble()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareNotGreaterThanScalar(
+ var result = Sse2.CompareScalarNotGreaterThan(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareNotGreaterThanScalar(
+ var result = Sse2.CompareScalarNotGreaterThan(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareNotGreaterThanScalar(
+ var result = Sse2.CompareScalarNotGreaterThan(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotGreaterThanScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotGreaterThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotGreaterThanScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotGreaterThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotGreaterThanScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotGreaterThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareNotGreaterThanScalar(
+ var result = Sse2.CompareScalarNotGreaterThan(
_clsVar1,
_clsVar2
);
fixed (Vector128<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
- var result = Sse2.CompareNotGreaterThanScalar(
+ var result = Sse2.CompareScalarNotGreaterThan(
Sse2.LoadVector128((Double*)(pClsVar1)),
Sse2.LoadVector128((Double*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareNotGreaterThanScalar(left, right);
+ var result = Sse2.CompareScalarNotGreaterThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotGreaterThanScalar(left, right);
+ var result = Sse2.CompareScalarNotGreaterThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotGreaterThanScalar(left, right);
+ var result = Sse2.CompareScalarNotGreaterThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareNotGreaterThanScalarDouble();
- var result = Sse2.CompareNotGreaterThanScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarNotGreaterThanDouble();
+ var result = Sse2.CompareScalarNotGreaterThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareNotGreaterThanScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarNotGreaterThanDouble();
fixed (Vector128<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
- var result = Sse2.CompareNotGreaterThanScalar(
+ var result = Sse2.CompareScalarNotGreaterThan(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareNotGreaterThanScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarNotGreaterThan(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareNotGreaterThanScalar(
+ var result = Sse2.CompareScalarNotGreaterThan(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareNotGreaterThanScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarNotGreaterThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse2.CompareNotGreaterThanScalar(
+ var result = Sse2.CompareScalarNotGreaterThan(
Sse2.LoadVector128((Double*)(&test._fld1)),
Sse2.LoadVector128((Double*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotGreaterThanScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarNotGreaterThan)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotGreaterThanOrEqualScalarDouble()
+ private static void CompareScalarNotGreaterThanOrEqualDouble()
{
- var test = new SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualDouble();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarDouble
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualDouble
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarDouble testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualDouble testClass)
{
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarDouble testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualDouble testClass)
{
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Double, Double, Double> _dataTable;
- static SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarDouble()
+ static SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualDouble()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarDouble()
+ public SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualDouble()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotGreaterThanOrEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotGreaterThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotGreaterThanOrEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotGreaterThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotGreaterThanOrEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotGreaterThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(
_clsVar1,
_clsVar2
);
fixed (Vector128<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(pClsVar1)),
Sse2.LoadVector128((Double*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(left, right);
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(left, right);
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(left, right);
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarDouble();
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualDouble();
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarNotGreaterThanOrEqualDouble();
fixed (Vector128<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse2.CompareNotGreaterThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(&test._fld1)),
Sse2.LoadVector128((Double*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotGreaterThanOrEqualScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarNotGreaterThanOrEqual)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotLessThanScalarDouble()
+ private static void CompareScalarNotLessThanDouble()
{
- var test = new SimpleBinaryOpTest__CompareNotLessThanScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarNotLessThanDouble();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareNotLessThanScalarDouble
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarNotLessThanDouble
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareNotLessThanScalarDouble testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarNotLessThanDouble testClass)
{
- var result = Sse2.CompareNotLessThanScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarNotLessThan(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareNotLessThanScalarDouble testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarNotLessThanDouble testClass)
{
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareNotLessThanScalar(
+ var result = Sse2.CompareScalarNotLessThan(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Double, Double, Double> _dataTable;
- static SimpleBinaryOpTest__CompareNotLessThanScalarDouble()
+ static SimpleBinaryOpTest__CompareScalarNotLessThanDouble()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public SimpleBinaryOpTest__CompareNotLessThanScalarDouble()
+ public SimpleBinaryOpTest__CompareScalarNotLessThanDouble()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareNotLessThanScalar(
+ var result = Sse2.CompareScalarNotLessThan(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareNotLessThanScalar(
+ var result = Sse2.CompareScalarNotLessThan(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareNotLessThanScalar(
+ var result = Sse2.CompareScalarNotLessThan(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotLessThanScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotLessThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotLessThanScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotLessThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotLessThanScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotLessThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareNotLessThanScalar(
+ var result = Sse2.CompareScalarNotLessThan(
_clsVar1,
_clsVar2
);
fixed (Vector128<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
- var result = Sse2.CompareNotLessThanScalar(
+ var result = Sse2.CompareScalarNotLessThan(
Sse2.LoadVector128((Double*)(pClsVar1)),
Sse2.LoadVector128((Double*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareNotLessThanScalar(left, right);
+ var result = Sse2.CompareScalarNotLessThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotLessThanScalar(left, right);
+ var result = Sse2.CompareScalarNotLessThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotLessThanScalar(left, right);
+ var result = Sse2.CompareScalarNotLessThan(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareNotLessThanScalarDouble();
- var result = Sse2.CompareNotLessThanScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarNotLessThanDouble();
+ var result = Sse2.CompareScalarNotLessThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareNotLessThanScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarNotLessThanDouble();
fixed (Vector128<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
- var result = Sse2.CompareNotLessThanScalar(
+ var result = Sse2.CompareScalarNotLessThan(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareNotLessThanScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarNotLessThan(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareNotLessThanScalar(
+ var result = Sse2.CompareScalarNotLessThan(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareNotLessThanScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarNotLessThan(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse2.CompareNotLessThanScalar(
+ var result = Sse2.CompareScalarNotLessThan(
Sse2.LoadVector128((Double*)(&test._fld1)),
Sse2.LoadVector128((Double*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotLessThanScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarNotLessThan)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotLessThanOrEqualScalarDouble()
+ private static void CompareScalarNotLessThanOrEqualDouble()
{
- var test = new SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualDouble();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarDouble
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualDouble
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarDouble testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualDouble testClass)
{
- var result = Sse2.CompareNotLessThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarNotLessThanOrEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarDouble testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualDouble testClass)
{
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareNotLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotLessThanOrEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Double, Double, Double> _dataTable;
- static SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarDouble()
+ static SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualDouble()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarDouble()
+ public SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualDouble()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareNotLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotLessThanOrEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareNotLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotLessThanOrEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareNotLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotLessThanOrEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotLessThanOrEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotLessThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotLessThanOrEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotLessThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotLessThanOrEqualScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarNotLessThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareNotLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotLessThanOrEqual(
_clsVar1,
_clsVar2
);
fixed (Vector128<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
- var result = Sse2.CompareNotLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotLessThanOrEqual(
Sse2.LoadVector128((Double*)(pClsVar1)),
Sse2.LoadVector128((Double*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareNotLessThanOrEqualScalar(left, right);
+ var result = Sse2.CompareScalarNotLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotLessThanOrEqualScalar(left, right);
+ var result = Sse2.CompareScalarNotLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotLessThanOrEqualScalar(left, right);
+ var result = Sse2.CompareScalarNotLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarDouble();
- var result = Sse2.CompareNotLessThanOrEqualScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualDouble();
+ var result = Sse2.CompareScalarNotLessThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarNotLessThanOrEqualDouble();
fixed (Vector128<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
- var result = Sse2.CompareNotLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotLessThanOrEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareNotLessThanOrEqualScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarNotLessThanOrEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareNotLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotLessThanOrEqual(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareNotLessThanOrEqualScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarNotLessThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse2.CompareNotLessThanOrEqualScalar(
+ var result = Sse2.CompareScalarNotLessThanOrEqual(
Sse2.LoadVector128((Double*)(&test._fld1)),
Sse2.LoadVector128((Double*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotLessThanOrEqualScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarNotLessThanOrEqual)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareOrderedScalarDouble()
+ private static void CompareScalarOrderedDouble()
{
- var test = new SimpleBinaryOpTest__CompareOrderedScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarOrderedDouble();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareOrderedScalarDouble
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarOrderedDouble
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareOrderedScalarDouble testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarOrderedDouble testClass)
{
- var result = Sse2.CompareOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrdered(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareOrderedScalarDouble testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarOrderedDouble testClass)
{
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareOrderedScalar(
+ var result = Sse2.CompareScalarOrdered(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Double, Double, Double> _dataTable;
- static SimpleBinaryOpTest__CompareOrderedScalarDouble()
+ static SimpleBinaryOpTest__CompareScalarOrderedDouble()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public SimpleBinaryOpTest__CompareOrderedScalarDouble()
+ public SimpleBinaryOpTest__CompareScalarOrderedDouble()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareOrderedScalar(
+ var result = Sse2.CompareScalarOrdered(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareOrderedScalar(
+ var result = Sse2.CompareScalarOrdered(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareOrderedScalar(
+ var result = Sse2.CompareScalarOrdered(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrdered), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrdered), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrdered), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareOrderedScalar(
+ var result = Sse2.CompareScalarOrdered(
_clsVar1,
_clsVar2
);
fixed (Vector128<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
- var result = Sse2.CompareOrderedScalar(
+ var result = Sse2.CompareScalarOrdered(
Sse2.LoadVector128((Double*)(pClsVar1)),
Sse2.LoadVector128((Double*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrdered(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrdered(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrdered(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareOrderedScalarDouble();
- var result = Sse2.CompareOrderedScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarOrderedDouble();
+ var result = Sse2.CompareScalarOrdered(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareOrderedScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarOrderedDouble();
fixed (Vector128<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
- var result = Sse2.CompareOrderedScalar(
+ var result = Sse2.CompareScalarOrdered(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrdered(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareOrderedScalar(
+ var result = Sse2.CompareScalarOrdered(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareOrderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarOrdered(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse2.CompareOrderedScalar(
+ var result = Sse2.CompareScalarOrdered(
Sse2.LoadVector128((Double*)(&test._fld1)),
Sse2.LoadVector128((Double*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareOrderedScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarOrdered)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareEqualOrderedScalarBoolean()
+ private static void CompareScalarOrderedEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarOrderedEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarOrderedEqualBoolean testClass)
{
- var result = Sse2.CompareEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrderedEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Double, Double> _dataTable;
- static BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarOrderedEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarOrderedEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqualOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqualOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqualOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareEqualOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareEqualOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareEqualOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean();
- var result = Sse2.CompareEqualOrderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedEqualBoolean();
+ var result = Sse2.CompareScalarOrderedEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrderedEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareEqualOrderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarOrderedEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] == right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqualOrderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarOrderedEqual)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareGreaterThanOrderedScalarBoolean()
+ private static void CompareScalarOrderedGreaterThanBoolean()
{
- var test = new BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedGreaterThanBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarOrderedGreaterThanBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarOrderedGreaterThanBoolean testClass)
{
- var result = Sse2.CompareGreaterThanOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrderedGreaterThan(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Double, Double> _dataTable;
- static BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarOrderedGreaterThanBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarOrderedGreaterThanBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareGreaterThanOrderedScalar(
+ var result = Sse2.CompareScalarOrderedGreaterThan(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareGreaterThanOrderedScalar(
+ var result = Sse2.CompareScalarOrderedGreaterThan(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareGreaterThanOrderedScalar(
+ var result = Sse2.CompareScalarOrderedGreaterThan(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedGreaterThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedGreaterThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedGreaterThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareGreaterThanOrderedScalar(
+ var result = Sse2.CompareScalarOrderedGreaterThan(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareGreaterThanOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedGreaterThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareGreaterThanOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedGreaterThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareGreaterThanOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedGreaterThan(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean();
- var result = Sse2.CompareGreaterThanOrderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedGreaterThanBoolean();
+ var result = Sse2.CompareScalarOrderedGreaterThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareGreaterThanOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrderedGreaterThan(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareGreaterThanOrderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarOrderedGreaterThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] > right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanOrderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarOrderedGreaterThan)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareGreaterThanOrEqualOrderedScalarBoolean()
+ private static void CompareScalarOrderedGreaterThanOrEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedGreaterThanOrEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarOrderedGreaterThanOrEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarOrderedGreaterThanOrEqualBoolean testClass)
{
- var result = Sse2.CompareGreaterThanOrEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrderedGreaterThanOrEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Double, Double> _dataTable;
- static BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarOrderedGreaterThanOrEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarOrderedGreaterThanOrEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareGreaterThanOrEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedGreaterThanOrEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareGreaterThanOrEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareGreaterThanOrEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedGreaterThanOrEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqualOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedGreaterThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqualOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedGreaterThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqualOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedGreaterThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareGreaterThanOrEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedGreaterThanOrEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareGreaterThanOrEqualOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedGreaterThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareGreaterThanOrEqualOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedGreaterThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareGreaterThanOrEqualOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedGreaterThanOrEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean();
- var result = Sse2.CompareGreaterThanOrEqualOrderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedGreaterThanOrEqualBoolean();
+ var result = Sse2.CompareScalarOrderedGreaterThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareGreaterThanOrEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrderedGreaterThanOrEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareGreaterThanOrEqualOrderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarOrderedGreaterThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] >= right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanOrEqualOrderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarOrderedGreaterThanOrEqual)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareLessThanOrderedScalarBoolean()
+ private static void CompareScalarOrderedLessThanBoolean()
{
- var test = new BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedLessThanBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarOrderedLessThanBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarOrderedLessThanBoolean testClass)
{
- var result = Sse2.CompareLessThanOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrderedLessThan(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Double, Double> _dataTable;
- static BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarOrderedLessThanBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarOrderedLessThanBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareLessThanOrderedScalar(
+ var result = Sse2.CompareScalarOrderedLessThan(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareLessThanOrderedScalar(
+ var result = Sse2.CompareScalarOrderedLessThan(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareLessThanOrderedScalar(
+ var result = Sse2.CompareScalarOrderedLessThan(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedLessThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedLessThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedLessThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareLessThanOrderedScalar(
+ var result = Sse2.CompareScalarOrderedLessThan(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareLessThanOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedLessThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareLessThanOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedLessThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareLessThanOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedLessThan(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean();
- var result = Sse2.CompareLessThanOrderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedLessThanBoolean();
+ var result = Sse2.CompareScalarOrderedLessThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareLessThanOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrderedLessThan(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareLessThanOrderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarOrderedLessThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] < right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanOrderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarOrderedLessThan)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareLessThanOrEqualOrderedScalarBoolean()
+ private static void CompareScalarOrderedLessThanOrEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedLessThanOrEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarOrderedLessThanOrEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarOrderedLessThanOrEqualBoolean testClass)
{
- var result = Sse2.CompareLessThanOrEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrderedLessThanOrEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Double, Double> _dataTable;
- static BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarOrderedLessThanOrEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarOrderedLessThanOrEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareLessThanOrEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedLessThanOrEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareLessThanOrEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedLessThanOrEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareLessThanOrEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedLessThanOrEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrEqualOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedLessThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrEqualOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedLessThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrEqualOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedLessThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareLessThanOrEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedLessThanOrEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareLessThanOrEqualOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedLessThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareLessThanOrEqualOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedLessThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareLessThanOrEqualOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedLessThanOrEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean();
- var result = Sse2.CompareLessThanOrEqualOrderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedLessThanOrEqualBoolean();
+ var result = Sse2.CompareScalarOrderedLessThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareLessThanOrEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrderedLessThanOrEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareLessThanOrEqualOrderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarOrderedLessThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] <= right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanOrEqualOrderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarOrderedLessThanOrEqual)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotEqualOrderedScalarBoolean()
+ private static void CompareScalarOrderedNotEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedNotEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarOrderedNotEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarOrderedNotEqualBoolean testClass)
{
- var result = Sse2.CompareNotEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrderedNotEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Double, Double> _dataTable;
- static BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarOrderedNotEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarOrderedNotEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareNotEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedNotEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareNotEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedNotEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareNotEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedNotEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotEqualOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedNotEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotEqualOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedNotEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotEqualOrderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarOrderedNotEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareNotEqualOrderedScalar(
+ var result = Sse2.CompareScalarOrderedNotEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareNotEqualOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedNotEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotEqualOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedNotEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotEqualOrderedScalar(left, right);
+ var result = Sse2.CompareScalarOrderedNotEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean();
- var result = Sse2.CompareNotEqualOrderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarOrderedNotEqualBoolean();
+ var result = Sse2.CompareScalarOrderedNotEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareNotEqualOrderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarOrderedNotEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareNotEqualOrderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarOrderedNotEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] != right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotEqualOrderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarOrderedNotEqual)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareUnorderedScalarDouble()
+ private static void CompareScalarUnorderedDouble()
{
- var test = new SimpleBinaryOpTest__CompareUnorderedScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarUnorderedDouble();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__CompareUnorderedScalarDouble
+ public sealed unsafe class SimpleBinaryOpTest__CompareScalarUnorderedDouble
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__CompareUnorderedScalarDouble testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__CompareScalarUnorderedDouble testClass)
{
- var result = Sse2.CompareUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnordered(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareUnorderedScalarDouble testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareScalarUnorderedDouble testClass)
{
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareUnorderedScalar(
+ var result = Sse2.CompareScalarUnordered(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
private SimpleBinaryOpTest__DataTable<Double, Double, Double> _dataTable;
- static SimpleBinaryOpTest__CompareUnorderedScalarDouble()
+ static SimpleBinaryOpTest__CompareScalarUnorderedDouble()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public SimpleBinaryOpTest__CompareUnorderedScalarDouble()
+ public SimpleBinaryOpTest__CompareScalarUnorderedDouble()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareUnorderedScalar(
+ var result = Sse2.CompareScalarUnordered(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareUnorderedScalar(
+ var result = Sse2.CompareScalarUnordered(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareUnorderedScalar(
+ var result = Sse2.CompareScalarUnordered(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnordered), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnordered), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnordered), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareUnorderedScalar(
+ var result = Sse2.CompareScalarUnordered(
_clsVar1,
_clsVar2
);
fixed (Vector128<Double>* pClsVar1 = &_clsVar1)
fixed (Vector128<Double>* pClsVar2 = &_clsVar2)
{
- var result = Sse2.CompareUnorderedScalar(
+ var result = Sse2.CompareScalarUnordered(
Sse2.LoadVector128((Double*)(pClsVar1)),
Sse2.LoadVector128((Double*)(pClsVar2))
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnordered(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnordered(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnordered(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__CompareUnorderedScalarDouble();
- var result = Sse2.CompareUnorderedScalar(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__CompareScalarUnorderedDouble();
+ var result = Sse2.CompareScalarUnordered(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__CompareUnorderedScalarDouble();
+ var test = new SimpleBinaryOpTest__CompareScalarUnorderedDouble();
fixed (Vector128<Double>* pFld1 = &test._fld1)
fixed (Vector128<Double>* pFld2 = &test._fld2)
{
- var result = Sse2.CompareUnorderedScalar(
+ var result = Sse2.CompareScalarUnordered(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnordered(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Double>* pFld1 = &_fld1)
fixed (Vector128<Double>* pFld2 = &_fld2)
{
- var result = Sse2.CompareUnorderedScalar(
+ var result = Sse2.CompareScalarUnordered(
Sse2.LoadVector128((Double*)(pFld1)),
Sse2.LoadVector128((Double*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarUnordered(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = Sse2.CompareUnorderedScalar(
+ var result = Sse2.CompareScalarUnordered(
Sse2.LoadVector128((Double*)(&test._fld1)),
Sse2.LoadVector128((Double*)(&test._fld2))
);
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareUnorderedScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarUnordered)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareEqualUnorderedScalarBoolean()
+ private static void CompareScalarUnorderedEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarUnorderedEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarUnorderedEqualBoolean testClass)
{
- var result = Sse2.CompareEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnorderedEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Double, Double> _dataTable;
- static BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarUnorderedEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarUnorderedEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqualUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqualUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqualUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareEqualUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareEqualUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareEqualUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean();
- var result = Sse2.CompareEqualUnorderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedEqualBoolean();
+ var result = Sse2.CompareScalarUnorderedEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnorderedEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareEqualUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarUnorderedEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] == right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqualUnorderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarUnorderedEqual)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareGreaterThanUnorderedScalarBoolean()
+ private static void CompareScalarUnorderedGreaterThanBoolean()
{
- var test = new BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanBoolean testClass)
{
- var result = Sse2.CompareGreaterThanUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnorderedGreaterThan(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Double, Double> _dataTable;
- static BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareGreaterThanUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedGreaterThan(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareGreaterThanUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedGreaterThan(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareGreaterThanUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedGreaterThan(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedGreaterThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedGreaterThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedGreaterThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareGreaterThanUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedGreaterThan(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareGreaterThanUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedGreaterThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareGreaterThanUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedGreaterThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareGreaterThanUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedGreaterThan(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean();
- var result = Sse2.CompareGreaterThanUnorderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanBoolean();
+ var result = Sse2.CompareScalarUnorderedGreaterThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareGreaterThanUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnorderedGreaterThan(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareGreaterThanUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarUnorderedGreaterThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] > right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanUnorderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarUnorderedGreaterThan)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareGreaterThanOrEqualUnorderedScalarBoolean()
+ private static void CompareScalarUnorderedGreaterThanOrEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanOrEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanOrEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanOrEqualBoolean testClass)
{
- var result = Sse2.CompareGreaterThanOrEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnorderedGreaterThanOrEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Double, Double> _dataTable;
- static BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanOrEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanOrEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareGreaterThanOrEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedGreaterThanOrEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareGreaterThanOrEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedGreaterThanOrEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareGreaterThanOrEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedGreaterThanOrEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedGreaterThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedGreaterThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedGreaterThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareGreaterThanOrEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedGreaterThanOrEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareGreaterThanOrEqualUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedGreaterThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareGreaterThanOrEqualUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedGreaterThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareGreaterThanOrEqualUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedGreaterThanOrEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean();
- var result = Sse2.CompareGreaterThanOrEqualUnorderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedGreaterThanOrEqualBoolean();
+ var result = Sse2.CompareScalarUnorderedGreaterThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareGreaterThanOrEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnorderedGreaterThanOrEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareGreaterThanOrEqualUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarUnorderedGreaterThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] >= right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanOrEqualUnorderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarUnorderedGreaterThanOrEqual)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareLessThanUnorderedScalarBoolean()
+ private static void CompareScalarUnorderedLessThanBoolean()
{
- var test = new BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedLessThanBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarUnorderedLessThanBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarUnorderedLessThanBoolean testClass)
{
- var result = Sse2.CompareLessThanUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnorderedLessThan(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Double, Double> _dataTable;
- static BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarUnorderedLessThanBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarUnorderedLessThanBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareLessThanUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedLessThan(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareLessThanUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedLessThan(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareLessThanUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedLessThan(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedLessThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedLessThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedLessThan), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareLessThanUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedLessThan(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareLessThanUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedLessThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareLessThanUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedLessThan(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareLessThanUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedLessThan(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean();
- var result = Sse2.CompareLessThanUnorderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedLessThanBoolean();
+ var result = Sse2.CompareScalarUnorderedLessThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareLessThanUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnorderedLessThan(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareLessThanUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarUnorderedLessThan(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] < right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanUnorderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarUnorderedLessThan)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareLessThanOrEqualUnorderedScalarBoolean()
+ private static void CompareScalarUnorderedLessThanOrEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedLessThanOrEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarUnorderedLessThanOrEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarUnorderedLessThanOrEqualBoolean testClass)
{
- var result = Sse2.CompareLessThanOrEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnorderedLessThanOrEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Double, Double> _dataTable;
- static BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarUnorderedLessThanOrEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarUnorderedLessThanOrEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareLessThanOrEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedLessThanOrEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareLessThanOrEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedLessThanOrEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareLessThanOrEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedLessThanOrEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedLessThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedLessThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedLessThanOrEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareLessThanOrEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedLessThanOrEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareLessThanOrEqualUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedLessThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareLessThanOrEqualUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedLessThanOrEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareLessThanOrEqualUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedLessThanOrEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean();
- var result = Sse2.CompareLessThanOrEqualUnorderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedLessThanOrEqualBoolean();
+ var result = Sse2.CompareScalarUnorderedLessThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareLessThanOrEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnorderedLessThanOrEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareLessThanOrEqualUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarUnorderedLessThanOrEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] <= right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanOrEqualUnorderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarUnorderedLessThanOrEqual)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void CompareNotEqualUnorderedScalarBoolean()
+ private static void CompareScalarUnorderedNotEqualBoolean()
{
- var test = new BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean();
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedNotEqualBoolean();
if (test.IsSupported)
{
}
}
- public sealed unsafe class BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean
+ public sealed unsafe class BooleanComparisonOpTest__CompareScalarUnorderedNotEqualBoolean
{
private struct TestStruct
{
return testStruct;
}
- public void RunStructFldScenario(BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean testClass)
+ public void RunStructFldScenario(BooleanComparisonOpTest__CompareScalarUnorderedNotEqualBoolean testClass)
{
- var result = Sse2.CompareNotEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnorderedNotEqual(_fld1, _fld2);
testClass.ValidateResult(_fld1, _fld2, result);
}
}
private BooleanComparisonOpTest__DataTable<Double, Double> _dataTable;
- static BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean()
+ static BooleanComparisonOpTest__CompareScalarUnorderedNotEqualBoolean()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Double>, byte>(ref _clsVar2), ref Unsafe.As<Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
}
- public BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean()
+ public BooleanComparisonOpTest__CompareScalarUnorderedNotEqualBoolean()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = Sse2.CompareNotEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedNotEqual(
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = Sse2.CompareNotEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedNotEqual(
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
- var result = Sse2.CompareNotEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedNotEqual(
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotEqualUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedNotEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotEqualUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedNotEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
- var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotEqualUnorderedScalar), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
+ var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareScalarUnorderedNotEqual), new Type[] { typeof(Vector128<Double>), typeof(Vector128<Double>) })
.Invoke(null, new object[] {
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)),
Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = Sse2.CompareNotEqualUnorderedScalar(
+ var result = Sse2.CompareScalarUnorderedNotEqual(
_clsVar1,
_clsVar2
);
var left = Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr);
var right = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
- var result = Sse2.CompareNotEqualUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedNotEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotEqualUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedNotEqual(left, right);
ValidateResult(left, right, result);
}
var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr));
var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr));
- var result = Sse2.CompareNotEqualUnorderedScalar(left, right);
+ var result = Sse2.CompareScalarUnorderedNotEqual(left, right);
ValidateResult(left, right, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean();
- var result = Sse2.CompareNotEqualUnorderedScalar(test._fld1, test._fld2);
+ var test = new BooleanComparisonOpTest__CompareScalarUnorderedNotEqualBoolean();
+ var result = Sse2.CompareScalarUnorderedNotEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = Sse2.CompareNotEqualUnorderedScalar(_fld1, _fld2);
+ var result = Sse2.CompareScalarUnorderedNotEqual(_fld1, _fld2);
ValidateResult(_fld1, _fld2, result);
}
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = Sse2.CompareNotEqualUnorderedScalar(test._fld1, test._fld2);
+ var result = Sse2.CompareScalarUnorderedNotEqual(test._fld1, test._fld2);
ValidateResult(test._fld1, test._fld2, result);
}
{
if ((left[0] != right[0]) != result)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotEqualUnorderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareScalarUnorderedNotEqual)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
["CompareEqual.SByte"] = CompareEqualSByte,
["CompareEqual.UInt16"] = CompareEqualUInt16,
["CompareEqual.UInt32"] = CompareEqualUInt32,
- ["CompareEqualScalar.Double"] = CompareEqualScalarDouble,
- ["CompareEqualOrderedScalar.Boolean"] = CompareEqualOrderedScalarBoolean,
- ["CompareEqualUnorderedScalar.Boolean"] = CompareEqualUnorderedScalarBoolean,
+ ["CompareScalarEqual.Double"] = CompareScalarEqualDouble,
+ ["CompareScalarOrderedEqual.Boolean"] = CompareScalarOrderedEqualBoolean,
+ ["CompareScalarUnorderedEqual.Boolean"] = CompareScalarUnorderedEqualBoolean,
["CompareGreaterThan.Double"] = CompareGreaterThanDouble,
["CompareGreaterThan.Int16"] = CompareGreaterThanInt16,
["CompareGreaterThan.Int32"] = CompareGreaterThanInt32,
["CompareGreaterThan.SByte"] = CompareGreaterThanSByte,
- ["CompareGreaterThanScalar.Double"] = CompareGreaterThanScalarDouble,
- ["CompareGreaterThanOrderedScalar.Boolean"] = CompareGreaterThanOrderedScalarBoolean,
- ["CompareGreaterThanUnorderedScalar.Boolean"] = CompareGreaterThanUnorderedScalarBoolean,
+ ["CompareScalarGreaterThan.Double"] = CompareScalarGreaterThanDouble,
+ ["CompareScalarOrderedGreaterThan.Boolean"] = CompareScalarOrderedGreaterThanBoolean,
+ ["CompareScalarUnorderedGreaterThan.Boolean"] = CompareScalarUnorderedGreaterThanBoolean,
["CompareGreaterThanOrEqual.Double"] = CompareGreaterThanOrEqualDouble,
- ["CompareGreaterThanOrEqualScalar.Double"] = CompareGreaterThanOrEqualScalarDouble,
- ["CompareGreaterThanOrEqualOrderedScalar.Boolean"] = CompareGreaterThanOrEqualOrderedScalarBoolean,
- ["CompareGreaterThanOrEqualUnorderedScalar.Boolean"] = CompareGreaterThanOrEqualUnorderedScalarBoolean,
+ ["CompareScalarGreaterThanOrEqual.Double"] = CompareScalarGreaterThanOrEqualDouble,
+ ["CompareScalarOrderedGreaterThanOrEqual.Boolean"] = CompareScalarOrderedGreaterThanOrEqualBoolean,
+ ["CompareScalarUnorderedGreaterThanOrEqual.Boolean"] = CompareScalarUnorderedGreaterThanOrEqualBoolean,
["CompareLessThan.Double"] = CompareLessThanDouble,
["CompareLessThan.Int16"] = CompareLessThanInt16,
["CompareLessThan.Int32"] = CompareLessThanInt32,
["CompareLessThan.SByte"] = CompareLessThanSByte,
- ["CompareLessThanScalar.Double"] = CompareLessThanScalarDouble,
- ["CompareLessThanOrderedScalar.Boolean"] = CompareLessThanOrderedScalarBoolean,
- ["CompareLessThanUnorderedScalar.Boolean"] = CompareLessThanUnorderedScalarBoolean,
+ ["CompareScalarLessThan.Double"] = CompareScalarLessThanDouble,
+ ["CompareScalarOrderedLessThan.Boolean"] = CompareScalarOrderedLessThanBoolean,
+ ["CompareScalarUnorderedLessThan.Boolean"] = CompareScalarUnorderedLessThanBoolean,
["CompareLessThanOrEqual.Double"] = CompareLessThanOrEqualDouble,
- ["CompareLessThanOrEqualScalar.Double"] = CompareLessThanOrEqualScalarDouble,
- ["CompareLessThanOrEqualOrderedScalar.Boolean"] = CompareLessThanOrEqualOrderedScalarBoolean,
- ["CompareLessThanOrEqualUnorderedScalar.Boolean"] = CompareLessThanOrEqualUnorderedScalarBoolean,
+ ["CompareScalarLessThanOrEqual.Double"] = CompareScalarLessThanOrEqualDouble,
+ ["CompareScalarOrderedLessThanOrEqual.Boolean"] = CompareScalarOrderedLessThanOrEqualBoolean,
+ ["CompareScalarUnorderedLessThanOrEqual.Boolean"] = CompareScalarUnorderedLessThanOrEqualBoolean,
["CompareNotEqual.Double"] = CompareNotEqualDouble,
- ["CompareNotEqualScalar.Double"] = CompareNotEqualScalarDouble,
- ["CompareNotEqualOrderedScalar.Boolean"] = CompareNotEqualOrderedScalarBoolean,
- ["CompareNotEqualUnorderedScalar.Boolean"] = CompareNotEqualUnorderedScalarBoolean,
+ ["CompareScalarNotEqual.Double"] = CompareScalarNotEqualDouble,
+ ["CompareScalarOrderedNotEqual.Boolean"] = CompareScalarOrderedNotEqualBoolean,
+ ["CompareScalarUnorderedNotEqual.Boolean"] = CompareScalarUnorderedNotEqualBoolean,
["CompareNotGreaterThan.Double"] = CompareNotGreaterThanDouble,
- ["CompareNotGreaterThanScalar.Double"] = CompareNotGreaterThanScalarDouble,
+ ["CompareScalarNotGreaterThan.Double"] = CompareScalarNotGreaterThanDouble,
["CompareNotGreaterThanOrEqual.Double"] = CompareNotGreaterThanOrEqualDouble,
- ["CompareNotGreaterThanOrEqualScalar.Double"] = CompareNotGreaterThanOrEqualScalarDouble,
+ ["CompareScalarNotGreaterThanOrEqual.Double"] = CompareScalarNotGreaterThanOrEqualDouble,
["CompareNotLessThan.Double"] = CompareNotLessThanDouble,
- ["CompareNotLessThanScalar.Double"] = CompareNotLessThanScalarDouble,
+ ["CompareScalarNotLessThan.Double"] = CompareScalarNotLessThanDouble,
["CompareNotLessThanOrEqual.Double"] = CompareNotLessThanOrEqualDouble,
- ["CompareNotLessThanOrEqualScalar.Double"] = CompareNotLessThanOrEqualScalarDouble,
+ ["CompareScalarNotLessThanOrEqual.Double"] = CompareScalarNotLessThanOrEqualDouble,
["CompareOrdered.Double"] = CompareOrderedDouble,
- ["CompareOrderedScalar.Double"] = CompareOrderedScalarDouble,
+ ["CompareScalarOrdered.Double"] = CompareScalarOrderedDouble,
["CompareUnordered.Double"] = CompareUnorderedDouble,
- ["CompareUnorderedScalar.Double"] = CompareUnorderedScalarDouble,
+ ["CompareScalarUnordered.Double"] = CompareScalarUnorderedDouble,
["ConvertToInt32.Vector128Double"] = ConvertToInt32Vector128Double,
["ConvertToInt32.Vector128Int32"] = ConvertToInt32Vector128Int32,
["ConvertToInt32WithTruncation.Vector128Double"] = ConvertToInt32WithTruncationVector128Double,
<Compile Include="Add.UInt16.cs" />
<Compile Include="Add.UInt32.cs" />
<Compile Include="Add.UInt64.cs" />
- <Compile Include="AddSaturate.Byte.cs"/>
- <Compile Include="AddSaturate.SByte.cs"/>
- <Compile Include="AddSaturate.Int16.cs"/>
- <Compile Include="AddSaturate.UInt16.cs"/>
- <Compile Include="AddScalar.Double.cs"/>
+ <Compile Include="AddSaturate.Byte.cs" />
+ <Compile Include="AddSaturate.SByte.cs" />
+ <Compile Include="AddSaturate.Int16.cs" />
+ <Compile Include="AddSaturate.UInt16.cs" />
+ <Compile Include="AddScalar.Double.cs" />
<Compile Include="And.Double.cs" />
<Compile Include="And.Byte.cs" />
<Compile Include="And.Int16.cs" />
<Compile Include="AndNot.UInt16.cs" />
<Compile Include="AndNot.UInt32.cs" />
<Compile Include="AndNot.UInt64.cs" />
- <Compile Include="Average.Byte.cs"/>
- <Compile Include="Average.UInt16.cs"/>
- <Compile Include="CompareEqual.Byte.cs" />
+ <Compile Include="Average.Byte.cs" />
+ <Compile Include="Average.UInt16.cs" />
<Compile Include="CompareEqual.Double.cs" />
+ <Compile Include="CompareEqual.Byte.cs" />
<Compile Include="CompareEqual.Int16.cs" />
<Compile Include="CompareEqual.Int32.cs" />
<Compile Include="CompareEqual.SByte.cs" />
<Compile Include="CompareEqual.UInt16.cs" />
<Compile Include="CompareEqual.UInt32.cs" />
- <Compile Include="CompareEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareEqualScalar.Double.cs" />
- <Compile Include="CompareEqualUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarEqual.Double.cs" />
+ <Compile Include="CompareScalarOrderedEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedEqual.Boolean.cs" />
<Compile Include="CompareGreaterThan.Double.cs" />
<Compile Include="CompareGreaterThan.Int16.cs" />
<Compile Include="CompareGreaterThan.Int32.cs" />
<Compile Include="CompareGreaterThan.SByte.cs" />
- <Compile Include="CompareGreaterThanOrderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarGreaterThan.Double.cs" />
+ <Compile Include="CompareScalarOrderedGreaterThan.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedGreaterThan.Boolean.cs" />
<Compile Include="CompareGreaterThanOrEqual.Double.cs" />
- <Compile Include="CompareGreaterThanOrEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareGreaterThanOrEqualScalar.Double.cs" />
- <Compile Include="CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs" />
- <Compile Include="CompareGreaterThanScalar.Double.cs" />
- <Compile Include="CompareGreaterThanUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarGreaterThanOrEqual.Double.cs" />
+ <Compile Include="CompareScalarOrderedGreaterThanOrEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedGreaterThanOrEqual.Boolean.cs" />
<Compile Include="CompareLessThan.Double.cs" />
<Compile Include="CompareLessThan.Int16.cs" />
<Compile Include="CompareLessThan.Int32.cs" />
<Compile Include="CompareLessThan.SByte.cs" />
- <Compile Include="CompareLessThanOrderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarLessThan.Double.cs" />
+ <Compile Include="CompareScalarOrderedLessThan.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedLessThan.Boolean.cs" />
<Compile Include="CompareLessThanOrEqual.Double.cs" />
- <Compile Include="CompareLessThanOrEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareLessThanOrEqualScalar.Double.cs" />
- <Compile Include="CompareLessThanOrEqualUnorderedScalar.Boolean.cs" />
- <Compile Include="CompareLessThanScalar.Double.cs" />
- <Compile Include="CompareLessThanUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarLessThanOrEqual.Double.cs" />
+ <Compile Include="CompareScalarOrderedLessThanOrEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedLessThanOrEqual.Boolean.cs" />
<Compile Include="CompareNotEqual.Double.cs" />
- <Compile Include="CompareNotEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareNotEqualScalar.Double.cs" />
- <Compile Include="CompareNotEqualUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarNotEqual.Double.cs" />
+ <Compile Include="CompareScalarOrderedNotEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedNotEqual.Boolean.cs" />
<Compile Include="CompareNotGreaterThan.Double.cs" />
+ <Compile Include="CompareScalarNotGreaterThan.Double.cs" />
<Compile Include="CompareNotGreaterThanOrEqual.Double.cs" />
- <Compile Include="CompareNotGreaterThanOrEqualScalar.Double.cs" />
- <Compile Include="CompareNotGreaterThanScalar.Double.cs" />
+ <Compile Include="CompareScalarNotGreaterThanOrEqual.Double.cs" />
<Compile Include="CompareNotLessThan.Double.cs" />
+ <Compile Include="CompareScalarNotLessThan.Double.cs" />
<Compile Include="CompareNotLessThanOrEqual.Double.cs" />
- <Compile Include="CompareNotLessThanOrEqualScalar.Double.cs" />
- <Compile Include="CompareNotLessThanScalar.Double.cs" />
+ <Compile Include="CompareScalarNotLessThanOrEqual.Double.cs" />
<Compile Include="CompareOrdered.Double.cs" />
- <Compile Include="CompareOrderedScalar.Double.cs" />
+ <Compile Include="CompareScalarOrdered.Double.cs" />
<Compile Include="CompareUnordered.Double.cs" />
- <Compile Include="CompareUnorderedScalar.Double.cs" />
+ <Compile Include="CompareScalarUnordered.Double.cs" />
<Compile Include="ConvertToInt32.Vector128Double.cs" />
<Compile Include="ConvertToInt32.Vector128Int32.cs" />
<Compile Include="ConvertToInt32WithTruncation.Vector128Double.cs" />
<Compile Include="Insert.UInt16.1.cs" />
<Compile Include="Insert.Int16.129.cs" />
<Compile Include="Insert.UInt16.129.cs" />
+ <Compile Include="LoadVector128.Double.cs" />
<Compile Include="LoadVector128.Byte.cs" />
<Compile Include="LoadVector128.SByte.cs" />
<Compile Include="LoadVector128.Int16.cs" />
<Compile Include="LoadVector128.UInt32.cs" />
<Compile Include="LoadVector128.Int64.cs" />
<Compile Include="LoadVector128.UInt64.cs" />
- <Compile Include="LoadVector128.Double.cs" />
<Compile Include="LoadScalarVector128.Double.cs" />
<Compile Include="LoadScalarVector128.Int32.cs" />
<Compile Include="LoadScalarVector128.UInt32.cs" />
<Compile Include="ShiftLeftLogical.UInt32.32.cs" />
<Compile Include="ShiftLeftLogical.Int64.64.cs" />
<Compile Include="ShiftLeftLogical.UInt64.64.cs" />
+ <Compile Include="ShiftLeftLogical128BitLane.SByte.1.cs" />
+ <Compile Include="ShiftLeftLogical128BitLane.Byte.1.cs" />
+ <Compile Include="ShiftLeftLogical128BitLane.Int16.1.cs" />
+ <Compile Include="ShiftLeftLogical128BitLane.UInt16.1.cs" />
+ <Compile Include="ShiftLeftLogical128BitLane.Int32.1.cs" />
+ <Compile Include="ShiftLeftLogical128BitLane.UInt32.1.cs" />
+ <Compile Include="ShiftLeftLogical128BitLane.Int64.1.cs" />
+ <Compile Include="ShiftLeftLogical128BitLane.UInt64.1.cs" />
+ <Compile Include="ShiftRightArithmetic.Int16.1.cs" />
+ <Compile Include="ShiftRightArithmetic.Int32.1.cs" />
+ <Compile Include="ShiftRightArithmetic.Int16.16.cs" />
+ <Compile Include="ShiftRightArithmetic.Int32.32.cs" />
<Compile Include="ShiftRightLogical.Int16.1.cs" />
<Compile Include="ShiftRightLogical.UInt16.1.cs" />
<Compile Include="ShiftRightLogical.Int32.1.cs" />
<Compile Include="ShiftRightLogical.UInt32.32.cs" />
<Compile Include="ShiftRightLogical.Int64.64.cs" />
<Compile Include="ShiftRightLogical.UInt64.64.cs" />
- <Compile Include="ShiftRightArithmetic.Int16.1.cs" />
- <Compile Include="ShiftRightArithmetic.Int32.1.cs" />
- <Compile Include="ShiftRightArithmetic.Int16.16.cs" />
- <Compile Include="ShiftRightArithmetic.Int32.32.cs" />
- <Compile Include="ShiftLeftLogical128BitLane.SByte.1.cs" />
- <Compile Include="ShiftLeftLogical128BitLane.Byte.1.cs" />
- <Compile Include="ShiftLeftLogical128BitLane.Int16.1.cs" />
- <Compile Include="ShiftLeftLogical128BitLane.UInt16.1.cs" />
- <Compile Include="ShiftLeftLogical128BitLane.Int32.1.cs" />
- <Compile Include="ShiftLeftLogical128BitLane.UInt32.1.cs" />
- <Compile Include="ShiftLeftLogical128BitLane.Int64.1.cs" />
- <Compile Include="ShiftLeftLogical128BitLane.UInt64.1.cs" />
<Compile Include="ShiftRightLogical128BitLane.SByte.1.cs" />
<Compile Include="ShiftRightLogical128BitLane.Byte.1.cs" />
<Compile Include="ShiftRightLogical128BitLane.Int16.1.cs" />
<Compile Include="Shuffle.Double.1.cs" />
<Compile Include="ShuffleHigh.Int16.0.cs" />
<Compile Include="ShuffleHigh.UInt16.0.cs" />
- <Compile Include="ShuffleHigh.Int16.1.cs" />
- <Compile Include="ShuffleHigh.UInt16.1.cs" />
<Compile Include="ShuffleLow.Int16.0.cs" />
<Compile Include="ShuffleLow.UInt16.0.cs" />
+ <Compile Include="ShuffleHigh.Int16.1.cs" />
+ <Compile Include="ShuffleHigh.UInt16.1.cs" />
<Compile Include="ShuffleLow.Int16.1.cs" />
<Compile Include="ShuffleLow.UInt16.1.cs" />
<Compile Include="Subtract.Double.cs" />
<Compile Include="Subtract.UInt16.cs" />
<Compile Include="Subtract.UInt32.cs" />
<Compile Include="Subtract.UInt64.cs" />
- <Compile Include="SubtractSaturate.Byte.cs"/>
- <Compile Include="SubtractSaturate.SByte.cs"/>
- <Compile Include="SubtractSaturate.Int16.cs"/>
- <Compile Include="SubtractSaturate.UInt16.cs"/>
+ <Compile Include="SubtractSaturate.Byte.cs" />
+ <Compile Include="SubtractSaturate.SByte.cs" />
+ <Compile Include="SubtractSaturate.Int16.cs" />
+ <Compile Include="SubtractSaturate.UInt16.cs" />
<Compile Include="SubtractScalar.Double.cs" />
<Compile Include="SumAbsoluteDifferences.UInt16.cs" />
<Compile Include="UnpackHigh.Double.cs" />
<Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
</ItemGroup>
<ItemGroup>
- <Compile Include="Add.Byte.cs" />
<Compile Include="Add.Double.cs" />
+ <Compile Include="Add.Byte.cs" />
<Compile Include="Add.Int16.cs" />
<Compile Include="Add.Int32.cs" />
<Compile Include="Add.Int64.cs" />
<Compile Include="Add.UInt16.cs" />
<Compile Include="Add.UInt32.cs" />
<Compile Include="Add.UInt64.cs" />
- <Compile Include="AddSaturate.Byte.cs"/>
- <Compile Include="AddSaturate.Int16.cs"/>
- <Compile Include="AddSaturate.SByte.cs"/>
- <Compile Include="AddSaturate.UInt16.cs"/>
- <Compile Include="AddScalar.Double.cs"/>
- <Compile Include="And.Byte.cs" />
+ <Compile Include="AddSaturate.Byte.cs" />
+ <Compile Include="AddSaturate.SByte.cs" />
+ <Compile Include="AddSaturate.Int16.cs" />
+ <Compile Include="AddSaturate.UInt16.cs" />
+ <Compile Include="AddScalar.Double.cs" />
<Compile Include="And.Double.cs" />
+ <Compile Include="And.Byte.cs" />
<Compile Include="And.Int16.cs" />
<Compile Include="And.Int32.cs" />
<Compile Include="And.Int64.cs" />
<Compile Include="And.UInt16.cs" />
<Compile Include="And.UInt32.cs" />
<Compile Include="And.UInt64.cs" />
- <Compile Include="AndNot.Byte.cs" />
<Compile Include="AndNot.Double.cs" />
+ <Compile Include="AndNot.Byte.cs" />
<Compile Include="AndNot.Int16.cs" />
<Compile Include="AndNot.Int32.cs" />
<Compile Include="AndNot.Int64.cs" />
<Compile Include="AndNot.UInt16.cs" />
<Compile Include="AndNot.UInt32.cs" />
<Compile Include="AndNot.UInt64.cs" />
- <Compile Include="Average.Byte.cs"/>
- <Compile Include="Average.UInt16.cs"/>
- <Compile Include="CompareEqual.Byte.cs" />
+ <Compile Include="Average.Byte.cs" />
+ <Compile Include="Average.UInt16.cs" />
<Compile Include="CompareEqual.Double.cs" />
+ <Compile Include="CompareEqual.Byte.cs" />
<Compile Include="CompareEqual.Int16.cs" />
<Compile Include="CompareEqual.Int32.cs" />
<Compile Include="CompareEqual.SByte.cs" />
<Compile Include="CompareEqual.UInt16.cs" />
<Compile Include="CompareEqual.UInt32.cs" />
- <Compile Include="CompareEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareEqualScalar.Double.cs" />
- <Compile Include="CompareEqualUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarEqual.Double.cs" />
+ <Compile Include="CompareScalarOrderedEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedEqual.Boolean.cs" />
<Compile Include="CompareGreaterThan.Double.cs" />
<Compile Include="CompareGreaterThan.Int16.cs" />
<Compile Include="CompareGreaterThan.Int32.cs" />
<Compile Include="CompareGreaterThan.SByte.cs" />
- <Compile Include="CompareGreaterThanOrderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarGreaterThan.Double.cs" />
+ <Compile Include="CompareScalarOrderedGreaterThan.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedGreaterThan.Boolean.cs" />
<Compile Include="CompareGreaterThanOrEqual.Double.cs" />
- <Compile Include="CompareGreaterThanOrEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareGreaterThanOrEqualScalar.Double.cs" />
- <Compile Include="CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs" />
- <Compile Include="CompareGreaterThanScalar.Double.cs" />
- <Compile Include="CompareGreaterThanUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarGreaterThanOrEqual.Double.cs" />
+ <Compile Include="CompareScalarOrderedGreaterThanOrEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedGreaterThanOrEqual.Boolean.cs" />
<Compile Include="CompareLessThan.Double.cs" />
<Compile Include="CompareLessThan.Int16.cs" />
<Compile Include="CompareLessThan.Int32.cs" />
<Compile Include="CompareLessThan.SByte.cs" />
- <Compile Include="CompareLessThanOrderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarLessThan.Double.cs" />
+ <Compile Include="CompareScalarOrderedLessThan.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedLessThan.Boolean.cs" />
<Compile Include="CompareLessThanOrEqual.Double.cs" />
- <Compile Include="CompareLessThanOrEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareLessThanOrEqualScalar.Double.cs" />
- <Compile Include="CompareLessThanOrEqualUnorderedScalar.Boolean.cs" />
- <Compile Include="CompareLessThanScalar.Double.cs" />
- <Compile Include="CompareLessThanUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarLessThanOrEqual.Double.cs" />
+ <Compile Include="CompareScalarOrderedLessThanOrEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedLessThanOrEqual.Boolean.cs" />
<Compile Include="CompareNotEqual.Double.cs" />
- <Compile Include="CompareNotEqualOrderedScalar.Boolean.cs" />
- <Compile Include="CompareNotEqualScalar.Double.cs" />
- <Compile Include="CompareNotEqualUnorderedScalar.Boolean.cs" />
+ <Compile Include="CompareScalarNotEqual.Double.cs" />
+ <Compile Include="CompareScalarOrderedNotEqual.Boolean.cs" />
+ <Compile Include="CompareScalarUnorderedNotEqual.Boolean.cs" />
<Compile Include="CompareNotGreaterThan.Double.cs" />
+ <Compile Include="CompareScalarNotGreaterThan.Double.cs" />
<Compile Include="CompareNotGreaterThanOrEqual.Double.cs" />
- <Compile Include="CompareNotGreaterThanOrEqualScalar.Double.cs" />
- <Compile Include="CompareNotGreaterThanScalar.Double.cs" />
+ <Compile Include="CompareScalarNotGreaterThanOrEqual.Double.cs" />
<Compile Include="CompareNotLessThan.Double.cs" />
+ <Compile Include="CompareScalarNotLessThan.Double.cs" />
<Compile Include="CompareNotLessThanOrEqual.Double.cs" />
- <Compile Include="CompareNotLessThanOrEqualScalar.Double.cs" />
- <Compile Include="CompareNotLessThanScalar.Double.cs" />
+ <Compile Include="CompareScalarNotLessThanOrEqual.Double.cs" />
<Compile Include="CompareOrdered.Double.cs" />
- <Compile Include="CompareOrderedScalar.Double.cs" />
+ <Compile Include="CompareScalarOrdered.Double.cs" />
<Compile Include="CompareUnordered.Double.cs" />
- <Compile Include="CompareUnorderedScalar.Double.cs" />
+ <Compile Include="CompareScalarUnordered.Double.cs" />
<Compile Include="ConvertToInt32.Vector128Double.cs" />
<Compile Include="ConvertToInt32.Vector128Int32.cs" />
<Compile Include="ConvertToInt32WithTruncation.Vector128Double.cs" />
<Compile Include="Extract.UInt16.1.cs" />
<Compile Include="Extract.UInt16.129.cs" />
<Compile Include="Insert.Int16.1.cs" />
- <Compile Include="Insert.Int16.129.cs" />
<Compile Include="Insert.UInt16.1.cs" />
+ <Compile Include="Insert.Int16.129.cs" />
<Compile Include="Insert.UInt16.129.cs" />
+ <Compile Include="LoadVector128.Double.cs" />
<Compile Include="LoadVector128.Byte.cs" />
<Compile Include="LoadVector128.SByte.cs" />
<Compile Include="LoadVector128.Int16.cs" />
<Compile Include="LoadVector128.UInt32.cs" />
<Compile Include="LoadVector128.Int64.cs" />
<Compile Include="LoadVector128.UInt64.cs" />
- <Compile Include="LoadVector128.Double.cs" />
<Compile Include="LoadScalarVector128.Double.cs" />
<Compile Include="LoadScalarVector128.Int32.cs" />
<Compile Include="LoadScalarVector128.UInt32.cs" />
<Compile Include="LoadScalarVector128.Int64.cs" />
<Compile Include="LoadScalarVector128.UInt64.cs" />
- <Compile Include="Max.Byte.cs" />
<Compile Include="Max.Double.cs" />
+ <Compile Include="Max.Byte.cs" />
<Compile Include="Max.Int16.cs" />
<Compile Include="MaxScalar.Double.cs" />
- <Compile Include="Min.Byte.cs" />
<Compile Include="Min.Double.cs" />
+ <Compile Include="Min.Byte.cs" />
<Compile Include="Min.Int16.cs" />
<Compile Include="MinScalar.Double.cs" />
<Compile Include="Multiply.Double.cs" />
<Compile Include="MoveMask.Vector128Byte.cs" />
<Compile Include="MoveMask.Vector128SByte.cs" />
<Compile Include="MoveMask.Vector128Double.cs" />
- <Compile Include="Or.Byte.cs" />
<Compile Include="Or.Double.cs" />
+ <Compile Include="Or.Byte.cs" />
<Compile Include="Or.Int16.cs" />
<Compile Include="Or.Int32.cs" />
<Compile Include="Or.Int64.cs" />
<Compile Include="PackSignedSaturate.Int16.cs" />
<Compile Include="PackSignedSaturate.SByte.cs" />
<Compile Include="PackUnsignedSaturate.Byte.cs" />
- <Compile Include="Program.Sse2.cs" />
<Compile Include="ShiftLeftLogical.Int16.1.cs" />
- <Compile Include="ShiftLeftLogical.Int16.16.cs" />
+ <Compile Include="ShiftLeftLogical.UInt16.1.cs" />
<Compile Include="ShiftLeftLogical.Int32.1.cs" />
- <Compile Include="ShiftLeftLogical.Int32.32.cs" />
+ <Compile Include="ShiftLeftLogical.UInt32.1.cs" />
<Compile Include="ShiftLeftLogical.Int64.1.cs" />
- <Compile Include="ShiftLeftLogical.Int64.64.cs" />
- <Compile Include="ShiftLeftLogical.UInt16.1.cs" />
+ <Compile Include="ShiftLeftLogical.UInt64.1.cs" />
+ <Compile Include="ShiftLeftLogical.Int16.16.cs" />
<Compile Include="ShiftLeftLogical.UInt16.16.cs" />
- <Compile Include="ShiftLeftLogical.UInt32.1.cs" />
+ <Compile Include="ShiftLeftLogical.Int32.32.cs" />
<Compile Include="ShiftLeftLogical.UInt32.32.cs" />
- <Compile Include="ShiftLeftLogical.UInt64.1.cs" />
+ <Compile Include="ShiftLeftLogical.Int64.64.cs" />
<Compile Include="ShiftLeftLogical.UInt64.64.cs" />
+ <Compile Include="ShiftLeftLogical128BitLane.SByte.1.cs" />
<Compile Include="ShiftLeftLogical128BitLane.Byte.1.cs" />
<Compile Include="ShiftLeftLogical128BitLane.Int16.1.cs" />
- <Compile Include="ShiftLeftLogical128BitLane.Int32.1.cs" />
- <Compile Include="ShiftLeftLogical128BitLane.Int64.1.cs" />
- <Compile Include="ShiftLeftLogical128BitLane.SByte.1.cs" />
<Compile Include="ShiftLeftLogical128BitLane.UInt16.1.cs" />
+ <Compile Include="ShiftLeftLogical128BitLane.Int32.1.cs" />
<Compile Include="ShiftLeftLogical128BitLane.UInt32.1.cs" />
+ <Compile Include="ShiftLeftLogical128BitLane.Int64.1.cs" />
<Compile Include="ShiftLeftLogical128BitLane.UInt64.1.cs" />
<Compile Include="ShiftRightArithmetic.Int16.1.cs" />
- <Compile Include="ShiftRightArithmetic.Int16.16.cs" />
<Compile Include="ShiftRightArithmetic.Int32.1.cs" />
+ <Compile Include="ShiftRightArithmetic.Int16.16.cs" />
<Compile Include="ShiftRightArithmetic.Int32.32.cs" />
<Compile Include="ShiftRightLogical.Int16.1.cs" />
- <Compile Include="ShiftRightLogical.Int16.16.cs" />
+ <Compile Include="ShiftRightLogical.UInt16.1.cs" />
<Compile Include="ShiftRightLogical.Int32.1.cs" />
- <Compile Include="ShiftRightLogical.Int32.32.cs" />
+ <Compile Include="ShiftRightLogical.UInt32.1.cs" />
<Compile Include="ShiftRightLogical.Int64.1.cs" />
- <Compile Include="ShiftRightLogical.Int64.64.cs" />
- <Compile Include="ShiftRightLogical.UInt16.1.cs" />
+ <Compile Include="ShiftRightLogical.UInt64.1.cs" />
+ <Compile Include="ShiftRightLogical.Int16.16.cs" />
<Compile Include="ShiftRightLogical.UInt16.16.cs" />
- <Compile Include="ShiftRightLogical.UInt32.1.cs" />
+ <Compile Include="ShiftRightLogical.Int32.32.cs" />
<Compile Include="ShiftRightLogical.UInt32.32.cs" />
- <Compile Include="ShiftRightLogical.UInt64.1.cs" />
+ <Compile Include="ShiftRightLogical.Int64.64.cs" />
<Compile Include="ShiftRightLogical.UInt64.64.cs" />
+ <Compile Include="ShiftRightLogical128BitLane.SByte.1.cs" />
<Compile Include="ShiftRightLogical128BitLane.Byte.1.cs" />
<Compile Include="ShiftRightLogical128BitLane.Int16.1.cs" />
- <Compile Include="ShiftRightLogical128BitLane.Int32.1.cs" />
- <Compile Include="ShiftRightLogical128BitLane.Int64.1.cs" />
- <Compile Include="ShiftRightLogical128BitLane.SByte.1.cs" />
<Compile Include="ShiftRightLogical128BitLane.UInt16.1.cs" />
+ <Compile Include="ShiftRightLogical128BitLane.Int32.1.cs" />
<Compile Include="ShiftRightLogical128BitLane.UInt32.1.cs" />
+ <Compile Include="ShiftRightLogical128BitLane.Int64.1.cs" />
<Compile Include="ShiftRightLogical128BitLane.UInt64.1.cs" />
<Compile Include="Shuffle.Int32.0.cs" />
<Compile Include="Shuffle.UInt32.0.cs" />
<Compile Include="Shuffle.Double.1.cs" />
<Compile Include="ShuffleHigh.Int16.0.cs" />
<Compile Include="ShuffleHigh.UInt16.0.cs" />
- <Compile Include="ShuffleHigh.Int16.1.cs" />
- <Compile Include="ShuffleHigh.UInt16.1.cs" />
<Compile Include="ShuffleLow.Int16.0.cs" />
<Compile Include="ShuffleLow.UInt16.0.cs" />
+ <Compile Include="ShuffleHigh.Int16.1.cs" />
+ <Compile Include="ShuffleHigh.UInt16.1.cs" />
<Compile Include="ShuffleLow.Int16.1.cs" />
<Compile Include="ShuffleLow.UInt16.1.cs" />
- <Compile Include="Subtract.Byte.cs" />
<Compile Include="Subtract.Double.cs" />
+ <Compile Include="Subtract.Byte.cs" />
<Compile Include="Subtract.Int16.cs" />
<Compile Include="Subtract.Int32.cs" />
<Compile Include="Subtract.Int64.cs" />
<Compile Include="Subtract.UInt16.cs" />
<Compile Include="Subtract.UInt32.cs" />
<Compile Include="Subtract.UInt64.cs" />
- <Compile Include="SubtractSaturate.Byte.cs"/>
- <Compile Include="SubtractSaturate.Int16.cs"/>
- <Compile Include="SubtractSaturate.SByte.cs"/>
- <Compile Include="SubtractSaturate.UInt16.cs"/>
+ <Compile Include="SubtractSaturate.Byte.cs" />
+ <Compile Include="SubtractSaturate.SByte.cs" />
+ <Compile Include="SubtractSaturate.Int16.cs" />
+ <Compile Include="SubtractSaturate.UInt16.cs" />
<Compile Include="SubtractScalar.Double.cs" />
<Compile Include="SumAbsoluteDifferences.UInt16.cs" />
<Compile Include="UnpackHigh.Double.cs" />
<Compile Include="UnpackLow.UInt16.cs" />
<Compile Include="UnpackLow.SByte.cs" />
<Compile Include="UnpackLow.Byte.cs" />
- <Compile Include="Xor.Byte.cs" />
<Compile Include="Xor.Double.cs" />
+ <Compile Include="Xor.Byte.cs" />
<Compile Include="Xor.Int16.cs" />
<Compile Include="Xor.Int32.cs" />
<Compile Include="Xor.Int64.cs" />
<Compile Include="Xor.UInt16.cs" />
<Compile Include="Xor.UInt32.cs" />
<Compile Include="Xor.UInt64.cs" />
+ <Compile Include="Program.Sse2.cs" />
<Compile Include="..\Shared\Program.cs" />
<Compile Include="..\Shared\BooleanCmpOpTest_DataTable.cs" />
<Compile Include="..\Shared\SimpleBinOpTest_DataTable.cs" />
public static Int32RGBPacket256 ConvertToIntRGB(this VectorPacket256 colors)
{
- var rsMask = Compare(colors.Xs, One, FloatComparisonMode.GreaterThanOrderedNonSignaling);
- var gsMask = Compare(colors.Ys, One, FloatComparisonMode.GreaterThanOrderedNonSignaling);
- var bsMask = Compare(colors.Zs, One, FloatComparisonMode.GreaterThanOrderedNonSignaling);
+ var rsMask = Compare(colors.Xs, One, FloatComparisonMode.OrderedGreaterThanNonSignaling);
+ var gsMask = Compare(colors.Ys, One, FloatComparisonMode.OrderedGreaterThanNonSignaling);
+ var bsMask = Compare(colors.Zs, One, FloatComparisonMode.OrderedGreaterThanNonSignaling);
var rs = BlendVariable(colors.Xs, One, rsMask);
var gs = BlendVariable(colors.Ys, One, gsMask);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool AllNullIntersections(Vector256<float> dis)
{
- var cmp = Compare(dis, NullDistance, FloatComparisonMode.EqualOrderedNonSignaling);
+ var cmp = Compare(dis, NullDistance, FloatComparisonMode.OrderedEqualNonSignaling);
var zero = Vector256<int>.Zero;
// efficiently generate an all-one mask vector by lower latency AVX2 ComapreEqual
var mask = Avx2.CompareEqual(zero, zero);
return ColorPacket256Helper.BackgroundColor;
}
var color = Shade(isect, rayPacket256, scene, depth);
- var isNull = Compare(isect.Distances, Intersections.NullDistance, FloatComparisonMode.EqualOrderedNonSignaling);
+ var isNull = Compare(isect.Distances, Intersections.NullDistance, FloatComparisonMode.OrderedEqualNonSignaling);
var backgroundColor = ColorPacket256Helper.BackgroundColor.Xs;
return new ColorPacket256(BlendVariable(color.Xs, backgroundColor, isNull),
BlendVariable(color.Ys, backgroundColor, isNull),
{
return Vector256<float>.Zero;
}
- var isNull = Compare(isect.Distances, Intersections.NullDistance, FloatComparisonMode.EqualOrderedNonSignaling);
+ var isNull = Compare(isect.Distances, Intersections.NullDistance, FloatComparisonMode.OrderedEqualNonSignaling);
return BlendVariable(isect.Distances, Vector256<float>.Zero, isNull);
}
if (!Intersections.AllNullIntersections(distance))
{
- var notNullMask = Compare(distance, Intersections.NullDistance, FloatComparisonMode.NotEqualOrderedNonSignaling);
- var nullMinMask = Compare(mins.Distances, Intersections.NullDistance, FloatComparisonMode.EqualOrderedNonSignaling);
+ var notNullMask = Compare(distance, Intersections.NullDistance, FloatComparisonMode.OrderedNotEqualNonSignaling);
+ var nullMinMask = Compare(mins.Distances, Intersections.NullDistance, FloatComparisonMode.OrderedEqualNonSignaling);
- var lessMinMask = Compare(mins.Distances, distance, FloatComparisonMode.GreaterThanOrderedNonSignaling);
+ var lessMinMask = Compare(mins.Distances, distance, FloatComparisonMode.OrderedGreaterThanNonSignaling);
var minMask = And(notNullMask, Or(nullMinMask, lessMinMask));
var minDis = BlendVariable(mins.Distances, distance, minMask);
var minIndices = BlendVariable(mins.ThingIndices.AsSingle(),
var neatIsectDis = TestRay(new RayPacket256(pos, livec), scene);
// is in shadow?
- var mask1 = Compare(neatIsectDis, ldis.Lengths, FloatComparisonMode.LessThanOrEqualOrderedNonSignaling);
- var mask2 = Compare(neatIsectDis, zero, FloatComparisonMode.NotEqualOrderedNonSignaling);
+ var mask1 = Compare(neatIsectDis, ldis.Lengths, FloatComparisonMode.OrderedLessThanOrEqualNonSignaling);
+ var mask2 = Compare(neatIsectDis, zero, FloatComparisonMode.OrderedNotEqualNonSignaling);
var isInShadow = And(mask1, mask2);
Vector256<float> illum = VectorPacket256.DotProduct(livec, norms);
- Vector256<float> illumGraterThanZero = Compare(illum, zero, FloatComparisonMode.GreaterThanOrderedNonSignaling);
+ Vector256<float> illumGraterThanZero = Compare(illum, zero, FloatComparisonMode.OrderedGreaterThanNonSignaling);
var tmpColor1 = illum * colorPacket;
var defaultRGB = zero;
Vector256<float> lcolorR = BlendVariable(defaultRGB, tmpColor1.Xs, illumGraterThanZero);
ColorPacket256 lcolor = new ColorPacket256(lcolorR, lcolorG, lcolorB);
Vector256<float> specular = VectorPacket256.DotProduct(livec, rds.Normalize());
- Vector256<float> specularGraterThanZero = Compare(specular, zero, FloatComparisonMode.GreaterThanOrderedNonSignaling);
+ Vector256<float> specularGraterThanZero = Compare(specular, zero, FloatComparisonMode.OrderedGreaterThanNonSignaling);
var difColor = new ColorPacket256(1, 1, 1);
var splColor = new ColorPacket256(1, 1, 1);
{
var denom = VectorPacket256.DotProduct(Norms, rayPacket256.Dirs);
var dist = Divide(Add(VectorPacket256.DotProduct(Norms, rayPacket256.Starts), Offsets), Subtract(Vector256<float>.Zero, denom));
- var gtMask = Compare(denom, Vector256<float>.Zero, FloatComparisonMode.GreaterThanOrderedNonSignaling);
+ var gtMask = Compare(denom, Vector256<float>.Zero, FloatComparisonMode.OrderedGreaterThanNonSignaling);
return BlendVariable(dist, Intersections.NullDistance, gtMask);
}
}
var eo = Centers - rayPacket256.Starts;
var v = VectorPacket256.DotProduct(eo, rayPacket256.Dirs);
var zero = Vector256<float>.Zero;
- var vLessZeroMask = Compare(v, zero, FloatComparisonMode.LessThanOrderedNonSignaling);
+ var vLessZeroMask = Compare(v, zero, FloatComparisonMode.OrderedLessThanNonSignaling);
var discs = Subtract(Multiply(Radiuses, Radiuses), Subtract(VectorPacket256.DotProduct(eo, eo), Multiply(v, v)));
- var discLessZeroMask = Compare(discs, zero, FloatComparisonMode.LessThanOrderedNonSignaling);
+ var discLessZeroMask = Compare(discs, zero, FloatComparisonMode.OrderedLessThanNonSignaling);
var dists = BlendVariable(Subtract(v, Sqrt(discs)), zero, Or(vLessZeroMask, discLessZeroMask));
- var isZero = Compare(dists, zero, FloatComparisonMode.EqualOrderedNonSignaling);
+ var isZero = Compare(dists, zero, FloatComparisonMode.OrderedEqualNonSignaling);
return BlendVariable(dists, Intersections.NullDistance, isZero);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector256<float> Log(Vector256<float> value)
{
- Vector256<float> invalidMask = Compare(value, Vector256<float>.Zero, FloatComparisonMode.LessThanOrEqualOrderedNonSignaling);
+ Vector256<float> invalidMask = Compare(value, Vector256<float>.Zero, FloatComparisonMode.OrderedLessThanOrEqualNonSignaling);
Vector256<float> x = Max(value, MinNormPos.AsSingle());
Vector256<int> ei = Avx2.ShiftRightLogical(x.AsInt32(), 23);
x = Or(And(x, MantMask.AsSingle()), Point5);
ei = Avx2.Subtract(ei, Ox7);
Vector256<float> e = Add(ConvertToVector256Single(ei), One);
- Vector256<float> mask = Compare(x, Sqrthf, FloatComparisonMode.LessThanOrderedNonSignaling);
+ Vector256<float> mask = Compare(x, Sqrthf, FloatComparisonMode.OrderedLessThanNonSignaling);
Vector256<float> tmp = And(x, mask);
x = Subtract(x, One);
e = Subtract(e, And(One, mask));
projects / platform / upstream / coreclr.git / commitdiff