diff --git a/src/Maths/Silk.NET.Maths.Benchmarks/Silk.NET.Maths.Benchmarks.csproj b/src/Maths/Silk.NET.Maths.Benchmarks/Silk.NET.Maths.Benchmarks.csproj index e929226e71..c56324c1af 100644 --- a/src/Maths/Silk.NET.Maths.Benchmarks/Silk.NET.Maths.Benchmarks.csproj +++ b/src/Maths/Silk.NET.Maths.Benchmarks/Silk.NET.Maths.Benchmarks.csproj @@ -17,21 +17,21 @@ - + TextTemplatingFileGenerator - SimdBenchmarkDissasm.cs + SimdBenchmarks.cs - + True True - SimdBenchmarkDissasm.tt + SimdBenchmarks.tt - + TextTemplatingFileGenerator - SimdBenchmarkDissasm.cs + SimdBenchmarks.cs diff --git a/src/Maths/Silk.NET.Maths.Benchmarks/SimdBenchmarkDissasm.cs b/src/Maths/Silk.NET.Maths.Benchmarks/SimdBenchmarkDissasm.cs deleted file mode 100644 index acb0a16994..0000000000 --- a/src/Maths/Silk.NET.Maths.Benchmarks/SimdBenchmarkDissasm.cs +++ /dev/null @@ -1,2204 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -#if NET5_0_OR_GREATER - -using System; -using System.Collections.Generic; -using System.Runtime.InteropServices; -using BenchmarkDotNet.Attributes; -using BenchmarkDotNet.Engines; -using BenchmarkDotNet.Jobs; -using System.Runtime.Intrinsics; - - -namespace Silk.NET.Maths.Benchmark -{ - [SimpleJob(RuntimeMoniker.Net50, launchCount: 1, warmupCount: 3, targetCount: 3)] - [DisassemblyDiagnoser(exportHtml: true)] - public unsafe class SIMDDisasm - { - const int IterCount = 30; - void* a; - void* b; - void* c; - - [GlobalSetup] - public void Setup() - { - // native memory is not a thing on .net 5 - var byteCount = 256/*bits*/ / 8 * IterCount; - a = (void*)Marshal.AllocHGlobal(byteCount); - b = (void*)Marshal.AllocHGlobal(byteCount); - c = (void*)Marshal.AllocHGlobal(byteCount); - var rand = new Random(); - for (int i = 0; i < byteCount; i++) - { - *(byte*)a = (byte)rand.Next(1, 255); - *(byte*)b = (byte)rand.Next(1, 255); - } - } - - [Benchmark] - public void Simd64GreaterThan_byte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThan_byte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64GreaterThanOrEqual_byte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThanOrEqual_byte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Add_byte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Subtract_byte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Multiply_byte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Divide_byte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Min_byte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Max_byte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Equal_byte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64NotEqual_byte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd128GreaterThan_byte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThan_byte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128GreaterThanOrEqual_byte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThanOrEqual_byte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Add_byte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Subtract_byte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Multiply_byte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Divide_byte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Min_byte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Max_byte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Equal_byte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128NotEqual_byte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd256GreaterThan_byte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThan_byte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256GreaterThanOrEqual_byte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThanOrEqual_byte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Add_byte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Subtract_byte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Multiply_byte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Divide_byte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Min_byte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Max_byte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Equal_byte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256NotEqual_byte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd64GreaterThan_sbyte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThan_sbyte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64GreaterThanOrEqual_sbyte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThanOrEqual_sbyte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Add_sbyte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Subtract_sbyte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Multiply_sbyte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Divide_sbyte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Min_sbyte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Max_sbyte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Equal_sbyte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64NotEqual_sbyte() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd128GreaterThan_sbyte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThan_sbyte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128GreaterThanOrEqual_sbyte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThanOrEqual_sbyte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Add_sbyte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Subtract_sbyte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Multiply_sbyte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Divide_sbyte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Min_sbyte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Max_sbyte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Equal_sbyte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128NotEqual_sbyte() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd256GreaterThan_sbyte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThan_sbyte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256GreaterThanOrEqual_sbyte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThanOrEqual_sbyte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Add_sbyte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Subtract_sbyte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Multiply_sbyte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Divide_sbyte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Min_sbyte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Max_sbyte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Equal_sbyte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256NotEqual_sbyte() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd64GreaterThan_ushort() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThan_ushort() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64GreaterThanOrEqual_ushort() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThanOrEqual_ushort() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Add_ushort() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Subtract_ushort() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Multiply_ushort() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Divide_ushort() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Min_ushort() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Max_ushort() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Equal_ushort() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64NotEqual_ushort() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd128GreaterThan_ushort() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThan_ushort() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128GreaterThanOrEqual_ushort() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThanOrEqual_ushort() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Add_ushort() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Subtract_ushort() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Multiply_ushort() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Divide_ushort() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Min_ushort() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Max_ushort() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Equal_ushort() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128NotEqual_ushort() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd256GreaterThan_ushort() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThan_ushort() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256GreaterThanOrEqual_ushort() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThanOrEqual_ushort() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Add_ushort() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Subtract_ushort() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Multiply_ushort() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Divide_ushort() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Min_ushort() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Max_ushort() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Equal_ushort() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256NotEqual_ushort() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd64GreaterThan_short() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThan_short() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64GreaterThanOrEqual_short() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThanOrEqual_short() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Add_short() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Subtract_short() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Multiply_short() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Divide_short() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Min_short() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Max_short() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Equal_short() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64NotEqual_short() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd128GreaterThan_short() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThan_short() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128GreaterThanOrEqual_short() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThanOrEqual_short() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Add_short() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Subtract_short() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Multiply_short() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Divide_short() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Min_short() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Max_short() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Equal_short() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128NotEqual_short() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd256GreaterThan_short() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThan_short() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256GreaterThanOrEqual_short() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThanOrEqual_short() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Add_short() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Subtract_short() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Multiply_short() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Divide_short() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Min_short() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Max_short() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Equal_short() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256NotEqual_short() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd64GreaterThan_uint() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThan_uint() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64GreaterThanOrEqual_uint() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThanOrEqual_uint() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Add_uint() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Subtract_uint() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Multiply_uint() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Divide_uint() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Min_uint() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Max_uint() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Equal_uint() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64NotEqual_uint() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd128GreaterThan_uint() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThan_uint() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128GreaterThanOrEqual_uint() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThanOrEqual_uint() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Add_uint() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Subtract_uint() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Multiply_uint() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Divide_uint() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Min_uint() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Max_uint() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Equal_uint() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128NotEqual_uint() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd256GreaterThan_uint() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThan_uint() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256GreaterThanOrEqual_uint() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThanOrEqual_uint() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Add_uint() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Subtract_uint() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Multiply_uint() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Divide_uint() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Min_uint() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Max_uint() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Equal_uint() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256NotEqual_uint() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd64GreaterThan_int() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThan_int() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64GreaterThanOrEqual_int() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThanOrEqual_int() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Add_int() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Subtract_int() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Multiply_int() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Divide_int() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Min_int() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Max_int() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Equal_int() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64NotEqual_int() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd128GreaterThan_int() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThan_int() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128GreaterThanOrEqual_int() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThanOrEqual_int() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Add_int() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Subtract_int() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Multiply_int() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Divide_int() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Min_int() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Max_int() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Equal_int() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128NotEqual_int() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd256GreaterThan_int() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThan_int() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256GreaterThanOrEqual_int() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThanOrEqual_int() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Add_int() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Subtract_int() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Multiply_int() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Divide_int() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Min_int() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Max_int() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Equal_int() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256NotEqual_int() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd64GreaterThan_ulong() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThan_ulong() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64GreaterThanOrEqual_ulong() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThanOrEqual_ulong() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Add_ulong() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Subtract_ulong() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Multiply_ulong() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Divide_ulong() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Min_ulong() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Max_ulong() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Equal_ulong() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64NotEqual_ulong() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd128GreaterThan_ulong() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThan_ulong() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128GreaterThanOrEqual_ulong() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThanOrEqual_ulong() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Add_ulong() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Subtract_ulong() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Multiply_ulong() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Divide_ulong() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Min_ulong() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Max_ulong() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Equal_ulong() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128NotEqual_ulong() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd256GreaterThan_ulong() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThan_ulong() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256GreaterThanOrEqual_ulong() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThanOrEqual_ulong() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Add_ulong() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Subtract_ulong() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Multiply_ulong() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Divide_ulong() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Min_ulong() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Max_ulong() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Equal_ulong() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256NotEqual_ulong() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd64GreaterThan_long() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThan_long() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64GreaterThanOrEqual_long() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThanOrEqual_long() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Add_long() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Subtract_long() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Multiply_long() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Divide_long() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Min_long() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Max_long() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Equal_long() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64NotEqual_long() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd128GreaterThan_long() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThan_long() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128GreaterThanOrEqual_long() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThanOrEqual_long() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Add_long() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Subtract_long() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Multiply_long() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Divide_long() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Min_long() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Max_long() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Equal_long() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128NotEqual_long() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd256GreaterThan_long() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThan_long() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256GreaterThanOrEqual_long() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThanOrEqual_long() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Add_long() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Subtract_long() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Multiply_long() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Divide_long() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Min_long() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Max_long() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Equal_long() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256NotEqual_long() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd64GreaterThan_float() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThan_float() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64GreaterThanOrEqual_float() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThanOrEqual_float() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Add_float() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Subtract_float() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Multiply_float() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Divide_float() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Min_float() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Max_float() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Equal_float() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64NotEqual_float() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd128GreaterThan_float() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThan_float() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128GreaterThanOrEqual_float() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThanOrEqual_float() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Add_float() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Subtract_float() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Multiply_float() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Divide_float() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Min_float() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Max_float() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Equal_float() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128NotEqual_float() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd256GreaterThan_float() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThan_float() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256GreaterThanOrEqual_float() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThanOrEqual_float() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Add_float() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Subtract_float() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Multiply_float() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Divide_float() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Min_float() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Max_float() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Equal_float() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256NotEqual_float() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd64GreaterThan_double() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThan_double() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64GreaterThanOrEqual_double() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64LessThanOrEqual_double() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Add_double() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Subtract_double() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Multiply_double() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Divide_double() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Min_double() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Max_double() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64Equal_double() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd64NotEqual_double() - { - for (int i = 0; i < IterCount * (4); i++) - *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); - } - [Benchmark] - public void Simd128GreaterThan_double() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThan_double() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128GreaterThanOrEqual_double() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128LessThanOrEqual_double() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Add_double() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Subtract_double() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Multiply_double() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Divide_double() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Min_double() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Max_double() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128Equal_double() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd128NotEqual_double() - { - for (int i = 0; i < IterCount * (2); i++) - *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); - } - [Benchmark] - public void Simd256GreaterThan_double() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThan_double() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256GreaterThanOrEqual_double() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256LessThanOrEqual_double() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Add_double() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Subtract_double() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Multiply_double() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Divide_double() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Min_double() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Max_double() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256Equal_double() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); - } - [Benchmark] - public void Simd256NotEqual_double() - { - for (int i = 0; i < IterCount * (1); i++) - *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); - } - } -} -#endif \ No newline at end of file diff --git a/src/Maths/Silk.NET.Maths.Benchmarks/SimdBenchmarks.cs b/src/Maths/Silk.NET.Maths.Benchmarks/SimdBenchmarks.cs new file mode 100644 index 0000000000..784e8e4452 --- /dev/null +++ b/src/Maths/Silk.NET.Maths.Benchmarks/SimdBenchmarks.cs @@ -0,0 +1,4874 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if NET5_0_OR_GREATER + +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using BenchmarkDotNet.Attributes; +using BenchmarkDotNet.Engines; +using BenchmarkDotNet.Jobs; +using System.Runtime.Intrinsics; + + +namespace Silk.NET.Maths.Benchmark +{ + [SimpleJob(RuntimeMoniker.Net50, launchCount: 1, warmupCount: 3, targetCount: 3)] + [DisassemblyDiagnoser(exportHtml: true)] + public unsafe class SimdBenchmarks + { + const int IterCount = 30; + void* a; + void* b; + void* c; + + [GlobalSetup] + public void Setup() + { + // native memory is not a thing on .net 5 + var byteCount = 256/*bits*/ / 8 * IterCount; + a = (void*)Marshal.AllocHGlobal(byteCount); + b = (void*)Marshal.AllocHGlobal(byteCount); + c = (void*)Marshal.AllocHGlobal(byteCount); + var rand = new Random(); + for (int i = 0; i < byteCount; i++) + { + *(byte*)a = (byte)rand.Next(1, 255); + *(byte*)b = (byte)rand.Next(1, 255); + } + } + + +#region Vector x Vector -> Vector 64-bit byte + + [Benchmark] + public void Simd64GreaterThan_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThan_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64GreaterThanOrEqual_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThanOrEqual_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Add_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Subtract_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Multiply_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Divide_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Min_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Max_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Equal_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64NotEqual_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64And_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.And(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Xor_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Xor(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Or_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Or(*((Vector64*)a + i), *((Vector64*)b + i)); + } + +#endregion + +#region Vector -> Vector 64-bit byte + + [Benchmark] + public void Simd64Not_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Not(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Abs_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Abs(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsFinite_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsFinite(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsInfinity_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNaN_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNaN(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegative_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegative(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegativeInfinity_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegativeInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNormal_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNormal(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsPositiveInfinity_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsPositiveInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Sign_byte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Sign(*((Vector64*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 128-bit byte + + [Benchmark] + public void Simd128GreaterThan_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThan_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128GreaterThanOrEqual_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThanOrEqual_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Add_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Subtract_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Multiply_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Divide_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Min_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Max_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Equal_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128NotEqual_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128And_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.And(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Xor_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Xor(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Or_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Or(*((Vector128*)a + i), *((Vector128*)b + i)); + } + +#endregion + +#region Vector -> Vector 128-bit byte + + [Benchmark] + public void Simd128Not_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Not(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Abs_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Abs(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsFinite_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsFinite(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsInfinity_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNaN_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNaN(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegative_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegative(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegativeInfinity_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegativeInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNormal_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNormal(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsPositiveInfinity_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsPositiveInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Sign_byte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Sign(*((Vector128*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 256-bit byte + + [Benchmark] + public void Simd256GreaterThan_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThan_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256GreaterThanOrEqual_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThanOrEqual_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Add_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Subtract_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Multiply_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Divide_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Min_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Max_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Equal_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256NotEqual_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256And_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.And(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Xor_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Xor(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Or_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Or(*((Vector256*)a + i), *((Vector256*)b + i)); + } + +#endregion + +#region Vector -> Vector 256-bit byte + + [Benchmark] + public void Simd256Not_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Not(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Abs_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Abs(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsFinite_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsFinite(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsInfinity_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNaN_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNaN(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegative_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegative(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegativeInfinity_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegativeInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNormal_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNormal(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsPositiveInfinity_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsPositiveInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Sign_byte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Sign(*((Vector256*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 64-bit sbyte + + [Benchmark] + public void Simd64GreaterThan_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThan_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64GreaterThanOrEqual_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThanOrEqual_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Add_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Subtract_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Multiply_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Divide_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Min_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Max_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Equal_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64NotEqual_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64And_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.And(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Xor_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Xor(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Or_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Or(*((Vector64*)a + i), *((Vector64*)b + i)); + } + +#endregion + +#region Vector -> Vector 64-bit sbyte + + [Benchmark] + public void Simd64Not_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Not(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Abs_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Abs(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsFinite_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsFinite(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsInfinity_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNaN_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNaN(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegative_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegative(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegativeInfinity_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegativeInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNormal_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNormal(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsPositiveInfinity_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsPositiveInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Sign_sbyte() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Sign(*((Vector64*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 128-bit sbyte + + [Benchmark] + public void Simd128GreaterThan_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThan_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128GreaterThanOrEqual_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThanOrEqual_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Add_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Subtract_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Multiply_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Divide_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Min_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Max_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Equal_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128NotEqual_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128And_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.And(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Xor_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Xor(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Or_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Or(*((Vector128*)a + i), *((Vector128*)b + i)); + } + +#endregion + +#region Vector -> Vector 128-bit sbyte + + [Benchmark] + public void Simd128Not_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Not(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Abs_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Abs(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsFinite_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsFinite(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsInfinity_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNaN_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNaN(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegative_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegative(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegativeInfinity_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegativeInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNormal_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNormal(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsPositiveInfinity_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsPositiveInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Sign_sbyte() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Sign(*((Vector128*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 256-bit sbyte + + [Benchmark] + public void Simd256GreaterThan_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThan_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256GreaterThanOrEqual_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThanOrEqual_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Add_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Subtract_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Multiply_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Divide_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Min_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Max_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Equal_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256NotEqual_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256And_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.And(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Xor_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Xor(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Or_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Or(*((Vector256*)a + i), *((Vector256*)b + i)); + } + +#endregion + +#region Vector -> Vector 256-bit sbyte + + [Benchmark] + public void Simd256Not_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Not(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Abs_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Abs(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsFinite_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsFinite(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsInfinity_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNaN_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNaN(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegative_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegative(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegativeInfinity_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegativeInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNormal_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNormal(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsPositiveInfinity_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsPositiveInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Sign_sbyte() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Sign(*((Vector256*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 64-bit ushort + + [Benchmark] + public void Simd64GreaterThan_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThan_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64GreaterThanOrEqual_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThanOrEqual_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Add_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Subtract_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Multiply_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Divide_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Min_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Max_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Equal_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64NotEqual_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64And_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.And(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Xor_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Xor(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Or_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Or(*((Vector64*)a + i), *((Vector64*)b + i)); + } + +#endregion + +#region Vector -> Vector 64-bit ushort + + [Benchmark] + public void Simd64Not_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Not(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Abs_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Abs(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsFinite_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsFinite(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsInfinity_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNaN_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNaN(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegative_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegative(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegativeInfinity_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegativeInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNormal_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNormal(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsPositiveInfinity_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsPositiveInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Sign_ushort() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Sign(*((Vector64*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 128-bit ushort + + [Benchmark] + public void Simd128GreaterThan_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThan_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128GreaterThanOrEqual_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThanOrEqual_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Add_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Subtract_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Multiply_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Divide_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Min_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Max_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Equal_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128NotEqual_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128And_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.And(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Xor_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Xor(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Or_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Or(*((Vector128*)a + i), *((Vector128*)b + i)); + } + +#endregion + +#region Vector -> Vector 128-bit ushort + + [Benchmark] + public void Simd128Not_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Not(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Abs_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Abs(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsFinite_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsFinite(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsInfinity_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNaN_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNaN(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegative_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegative(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegativeInfinity_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegativeInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNormal_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNormal(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsPositiveInfinity_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsPositiveInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Sign_ushort() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Sign(*((Vector128*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 256-bit ushort + + [Benchmark] + public void Simd256GreaterThan_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThan_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256GreaterThanOrEqual_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThanOrEqual_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Add_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Subtract_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Multiply_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Divide_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Min_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Max_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Equal_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256NotEqual_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256And_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.And(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Xor_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Xor(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Or_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Or(*((Vector256*)a + i), *((Vector256*)b + i)); + } + +#endregion + +#region Vector -> Vector 256-bit ushort + + [Benchmark] + public void Simd256Not_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Not(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Abs_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Abs(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsFinite_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsFinite(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsInfinity_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNaN_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNaN(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegative_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegative(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegativeInfinity_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegativeInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNormal_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNormal(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsPositiveInfinity_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsPositiveInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Sign_ushort() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Sign(*((Vector256*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 64-bit short + + [Benchmark] + public void Simd64GreaterThan_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThan_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64GreaterThanOrEqual_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThanOrEqual_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Add_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Subtract_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Multiply_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Divide_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Min_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Max_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Equal_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64NotEqual_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64And_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.And(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Xor_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Xor(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Or_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Or(*((Vector64*)a + i), *((Vector64*)b + i)); + } + +#endregion + +#region Vector -> Vector 64-bit short + + [Benchmark] + public void Simd64Not_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Not(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Abs_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Abs(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsFinite_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsFinite(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsInfinity_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNaN_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNaN(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegative_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegative(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegativeInfinity_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegativeInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNormal_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNormal(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsPositiveInfinity_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsPositiveInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Sign_short() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Sign(*((Vector64*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 128-bit short + + [Benchmark] + public void Simd128GreaterThan_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThan_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128GreaterThanOrEqual_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThanOrEqual_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Add_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Subtract_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Multiply_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Divide_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Min_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Max_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Equal_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128NotEqual_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128And_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.And(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Xor_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Xor(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Or_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Or(*((Vector128*)a + i), *((Vector128*)b + i)); + } + +#endregion + +#region Vector -> Vector 128-bit short + + [Benchmark] + public void Simd128Not_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Not(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Abs_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Abs(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsFinite_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsFinite(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsInfinity_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNaN_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNaN(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegative_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegative(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegativeInfinity_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegativeInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNormal_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNormal(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsPositiveInfinity_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsPositiveInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Sign_short() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Sign(*((Vector128*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 256-bit short + + [Benchmark] + public void Simd256GreaterThan_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThan_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256GreaterThanOrEqual_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThanOrEqual_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Add_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Subtract_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Multiply_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Divide_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Min_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Max_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Equal_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256NotEqual_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256And_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.And(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Xor_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Xor(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Or_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Or(*((Vector256*)a + i), *((Vector256*)b + i)); + } + +#endregion + +#region Vector -> Vector 256-bit short + + [Benchmark] + public void Simd256Not_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Not(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Abs_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Abs(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsFinite_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsFinite(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsInfinity_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNaN_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNaN(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegative_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegative(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegativeInfinity_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegativeInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNormal_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNormal(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsPositiveInfinity_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsPositiveInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Sign_short() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Sign(*((Vector256*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 64-bit uint + + [Benchmark] + public void Simd64GreaterThan_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThan_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64GreaterThanOrEqual_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThanOrEqual_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Add_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Subtract_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Multiply_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Divide_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Min_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Max_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Equal_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64NotEqual_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64And_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.And(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Xor_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Xor(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Or_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Or(*((Vector64*)a + i), *((Vector64*)b + i)); + } + +#endregion + +#region Vector -> Vector 64-bit uint + + [Benchmark] + public void Simd64Not_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Not(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Abs_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Abs(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsFinite_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsFinite(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsInfinity_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNaN_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNaN(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegative_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegative(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegativeInfinity_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegativeInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNormal_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNormal(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsPositiveInfinity_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsPositiveInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Sign_uint() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Sign(*((Vector64*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 128-bit uint + + [Benchmark] + public void Simd128GreaterThan_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThan_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128GreaterThanOrEqual_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThanOrEqual_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Add_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Subtract_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Multiply_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Divide_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Min_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Max_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Equal_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128NotEqual_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128And_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.And(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Xor_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Xor(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Or_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Or(*((Vector128*)a + i), *((Vector128*)b + i)); + } + +#endregion + +#region Vector -> Vector 128-bit uint + + [Benchmark] + public void Simd128Not_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Not(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Abs_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Abs(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsFinite_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsFinite(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsInfinity_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNaN_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNaN(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegative_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegative(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegativeInfinity_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegativeInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNormal_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNormal(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsPositiveInfinity_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsPositiveInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Sign_uint() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Sign(*((Vector128*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 256-bit uint + + [Benchmark] + public void Simd256GreaterThan_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThan_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256GreaterThanOrEqual_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThanOrEqual_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Add_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Subtract_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Multiply_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Divide_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Min_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Max_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Equal_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256NotEqual_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256And_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.And(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Xor_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Xor(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Or_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Or(*((Vector256*)a + i), *((Vector256*)b + i)); + } + +#endregion + +#region Vector -> Vector 256-bit uint + + [Benchmark] + public void Simd256Not_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Not(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Abs_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Abs(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsFinite_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsFinite(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsInfinity_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNaN_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNaN(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegative_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegative(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegativeInfinity_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegativeInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNormal_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNormal(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsPositiveInfinity_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsPositiveInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Sign_uint() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Sign(*((Vector256*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 64-bit int + + [Benchmark] + public void Simd64GreaterThan_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThan_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64GreaterThanOrEqual_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThanOrEqual_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Add_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Subtract_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Multiply_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Divide_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Min_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Max_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Equal_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64NotEqual_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64And_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.And(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Xor_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Xor(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Or_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Or(*((Vector64*)a + i), *((Vector64*)b + i)); + } + +#endregion + +#region Vector -> Vector 64-bit int + + [Benchmark] + public void Simd64Not_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Not(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Abs_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Abs(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsFinite_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsFinite(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsInfinity_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNaN_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNaN(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegative_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegative(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegativeInfinity_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegativeInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNormal_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNormal(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsPositiveInfinity_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsPositiveInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Sign_int() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Sign(*((Vector64*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 128-bit int + + [Benchmark] + public void Simd128GreaterThan_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThan_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128GreaterThanOrEqual_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThanOrEqual_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Add_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Subtract_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Multiply_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Divide_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Min_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Max_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Equal_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128NotEqual_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128And_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.And(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Xor_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Xor(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Or_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Or(*((Vector128*)a + i), *((Vector128*)b + i)); + } + +#endregion + +#region Vector -> Vector 128-bit int + + [Benchmark] + public void Simd128Not_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Not(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Abs_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Abs(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsFinite_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsFinite(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsInfinity_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNaN_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNaN(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegative_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegative(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegativeInfinity_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegativeInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNormal_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNormal(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsPositiveInfinity_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsPositiveInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Sign_int() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Sign(*((Vector128*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 256-bit int + + [Benchmark] + public void Simd256GreaterThan_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThan_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256GreaterThanOrEqual_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThanOrEqual_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Add_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Subtract_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Multiply_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Divide_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Min_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Max_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Equal_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256NotEqual_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256And_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.And(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Xor_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Xor(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Or_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Or(*((Vector256*)a + i), *((Vector256*)b + i)); + } + +#endregion + +#region Vector -> Vector 256-bit int + + [Benchmark] + public void Simd256Not_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Not(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Abs_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Abs(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsFinite_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsFinite(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsInfinity_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNaN_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNaN(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegative_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegative(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegativeInfinity_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegativeInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNormal_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNormal(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsPositiveInfinity_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsPositiveInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Sign_int() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Sign(*((Vector256*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 64-bit ulong + + [Benchmark] + public void Simd64GreaterThan_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThan_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64GreaterThanOrEqual_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThanOrEqual_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Add_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Subtract_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Multiply_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Divide_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Min_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Max_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Equal_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64NotEqual_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64And_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.And(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Xor_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Xor(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Or_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Or(*((Vector64*)a + i), *((Vector64*)b + i)); + } + +#endregion + +#region Vector -> Vector 64-bit ulong + + [Benchmark] + public void Simd64Not_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Not(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Abs_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Abs(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsFinite_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsFinite(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsInfinity_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNaN_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNaN(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegative_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegative(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegativeInfinity_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegativeInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNormal_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNormal(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsPositiveInfinity_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsPositiveInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Sign_ulong() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Sign(*((Vector64*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 128-bit ulong + + [Benchmark] + public void Simd128GreaterThan_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThan_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128GreaterThanOrEqual_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThanOrEqual_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Add_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Subtract_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Multiply_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Divide_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Min_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Max_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Equal_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128NotEqual_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128And_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.And(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Xor_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Xor(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Or_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Or(*((Vector128*)a + i), *((Vector128*)b + i)); + } + +#endregion + +#region Vector -> Vector 128-bit ulong + + [Benchmark] + public void Simd128Not_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Not(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Abs_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Abs(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsFinite_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsFinite(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsInfinity_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNaN_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNaN(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegative_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegative(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegativeInfinity_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegativeInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNormal_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNormal(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsPositiveInfinity_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsPositiveInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Sign_ulong() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Sign(*((Vector128*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 256-bit ulong + + [Benchmark] + public void Simd256GreaterThan_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThan_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256GreaterThanOrEqual_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThanOrEqual_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Add_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Subtract_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Multiply_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Divide_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Min_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Max_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Equal_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256NotEqual_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256And_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.And(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Xor_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Xor(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Or_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Or(*((Vector256*)a + i), *((Vector256*)b + i)); + } + +#endregion + +#region Vector -> Vector 256-bit ulong + + [Benchmark] + public void Simd256Not_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Not(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Abs_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Abs(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsFinite_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsFinite(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsInfinity_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNaN_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNaN(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegative_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegative(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegativeInfinity_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegativeInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNormal_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNormal(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsPositiveInfinity_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsPositiveInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Sign_ulong() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Sign(*((Vector256*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 64-bit long + + [Benchmark] + public void Simd64GreaterThan_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThan_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64GreaterThanOrEqual_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThanOrEqual_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Add_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Subtract_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Multiply_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Divide_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Min_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Max_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Equal_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64NotEqual_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64And_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.And(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Xor_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Xor(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Or_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Or(*((Vector64*)a + i), *((Vector64*)b + i)); + } + +#endregion + +#region Vector -> Vector 64-bit long + + [Benchmark] + public void Simd64Not_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Not(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Abs_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Abs(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsFinite_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsFinite(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsInfinity_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNaN_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNaN(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegative_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegative(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegativeInfinity_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegativeInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNormal_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNormal(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsPositiveInfinity_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsPositiveInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Sign_long() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Sign(*((Vector64*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 128-bit long + + [Benchmark] + public void Simd128GreaterThan_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThan_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128GreaterThanOrEqual_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThanOrEqual_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Add_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Subtract_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Multiply_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Divide_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Min_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Max_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Equal_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128NotEqual_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128And_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.And(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Xor_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Xor(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Or_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Or(*((Vector128*)a + i), *((Vector128*)b + i)); + } + +#endregion + +#region Vector -> Vector 128-bit long + + [Benchmark] + public void Simd128Not_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Not(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Abs_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Abs(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsFinite_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsFinite(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsInfinity_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNaN_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNaN(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegative_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegative(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegativeInfinity_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegativeInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNormal_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNormal(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsPositiveInfinity_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsPositiveInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Sign_long() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Sign(*((Vector128*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 256-bit long + + [Benchmark] + public void Simd256GreaterThan_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThan_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256GreaterThanOrEqual_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThanOrEqual_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Add_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Subtract_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Multiply_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Divide_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Min_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Max_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Equal_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256NotEqual_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256And_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.And(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Xor_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Xor(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Or_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Or(*((Vector256*)a + i), *((Vector256*)b + i)); + } + +#endregion + +#region Vector -> Vector 256-bit long + + [Benchmark] + public void Simd256Not_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Not(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Abs_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Abs(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsFinite_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsFinite(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsInfinity_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNaN_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNaN(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegative_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegative(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegativeInfinity_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegativeInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNormal_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNormal(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsPositiveInfinity_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsPositiveInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Sign_long() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Sign(*((Vector256*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 64-bit float + + [Benchmark] + public void Simd64GreaterThan_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThan_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64GreaterThanOrEqual_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThanOrEqual_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Add_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Subtract_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Multiply_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Divide_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Min_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Max_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Equal_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64NotEqual_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64And_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.And(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Xor_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Xor(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Or_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Or(*((Vector64*)a + i), *((Vector64*)b + i)); + } + +#endregion + +#region Vector -> Vector 64-bit float + + [Benchmark] + public void Simd64Not_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Not(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Abs_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Abs(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsFinite_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsFinite(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsInfinity_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNaN_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNaN(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegative_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegative(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegativeInfinity_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegativeInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNormal_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNormal(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsPositiveInfinity_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsPositiveInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Sign_float() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Sign(*((Vector64*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 128-bit float + + [Benchmark] + public void Simd128GreaterThan_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThan_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128GreaterThanOrEqual_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThanOrEqual_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Add_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Subtract_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Multiply_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Divide_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Min_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Max_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Equal_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128NotEqual_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128And_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.And(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Xor_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Xor(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Or_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Or(*((Vector128*)a + i), *((Vector128*)b + i)); + } + +#endregion + +#region Vector -> Vector 128-bit float + + [Benchmark] + public void Simd128Not_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Not(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Abs_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Abs(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsFinite_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsFinite(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsInfinity_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNaN_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNaN(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegative_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegative(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegativeInfinity_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegativeInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNormal_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNormal(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsPositiveInfinity_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsPositiveInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Sign_float() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Sign(*((Vector128*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 256-bit float + + [Benchmark] + public void Simd256GreaterThan_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThan_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256GreaterThanOrEqual_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThanOrEqual_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Add_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Subtract_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Multiply_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Divide_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Min_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Max_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Equal_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256NotEqual_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256And_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.And(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Xor_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Xor(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Or_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Or(*((Vector256*)a + i), *((Vector256*)b + i)); + } + +#endregion + +#region Vector -> Vector 256-bit float + + [Benchmark] + public void Simd256Not_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Not(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Abs_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Abs(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsFinite_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsFinite(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsInfinity_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNaN_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNaN(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegative_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegative(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegativeInfinity_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegativeInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNormal_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNormal(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsPositiveInfinity_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsPositiveInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Sign_float() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Sign(*((Vector256*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 64-bit double + + [Benchmark] + public void Simd64GreaterThan_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThan_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThan(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64GreaterThanOrEqual_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.GreaterThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64LessThanOrEqual_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.LessThanOrEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Add_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Add(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Subtract_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Subtract(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Multiply_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Multiply(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Divide_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Divide(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Min_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Min(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Max_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Max(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Equal_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Equal(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64NotEqual_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.NotEqual(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64And_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.And(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Xor_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Xor(*((Vector64*)a + i), *((Vector64*)b + i)); + } + [Benchmark] + public void Simd64Or_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Or(*((Vector64*)a + i), *((Vector64*)b + i)); + } + +#endregion + +#region Vector -> Vector 64-bit double + + [Benchmark] + public void Simd64Not_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Not(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Abs_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Abs(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsFinite_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsFinite(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsInfinity_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNaN_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNaN(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegative_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegative(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNegativeInfinity_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNegativeInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsNormal_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsNormal(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64IsPositiveInfinity_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.IsPositiveInfinity(*((Vector64*)a + i)); + } + [Benchmark] + public void Simd64Sign_double() + { + for (int i = 0; i < IterCount * (4); i++) + *((Vector64*)c + i) = Simd64.Sign(*((Vector64*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 128-bit double + + [Benchmark] + public void Simd128GreaterThan_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThan_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThan(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128GreaterThanOrEqual_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.GreaterThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128LessThanOrEqual_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.LessThanOrEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Add_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Add(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Subtract_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Subtract(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Multiply_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Multiply(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Divide_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Divide(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Min_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Min(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Max_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Max(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Equal_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Equal(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128NotEqual_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.NotEqual(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128And_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.And(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Xor_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Xor(*((Vector128*)a + i), *((Vector128*)b + i)); + } + [Benchmark] + public void Simd128Or_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Or(*((Vector128*)a + i), *((Vector128*)b + i)); + } + +#endregion + +#region Vector -> Vector 128-bit double + + [Benchmark] + public void Simd128Not_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Not(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Abs_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Abs(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsFinite_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsFinite(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsInfinity_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNaN_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNaN(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegative_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegative(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNegativeInfinity_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNegativeInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsNormal_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsNormal(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128IsPositiveInfinity_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.IsPositiveInfinity(*((Vector128*)a + i)); + } + [Benchmark] + public void Simd128Sign_double() + { + for (int i = 0; i < IterCount * (2); i++) + *((Vector128*)c + i) = Simd128.Sign(*((Vector128*)a + i)); + } + +#endregion + + +#region Vector x Vector -> Vector 256-bit double + + [Benchmark] + public void Simd256GreaterThan_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThan_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThan(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256GreaterThanOrEqual_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.GreaterThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256LessThanOrEqual_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.LessThanOrEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Add_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Add(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Subtract_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Subtract(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Multiply_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Multiply(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Divide_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Divide(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Min_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Min(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Max_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Max(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Equal_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Equal(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256NotEqual_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.NotEqual(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256And_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.And(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Xor_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Xor(*((Vector256*)a + i), *((Vector256*)b + i)); + } + [Benchmark] + public void Simd256Or_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Or(*((Vector256*)a + i), *((Vector256*)b + i)); + } + +#endregion + +#region Vector -> Vector 256-bit double + + [Benchmark] + public void Simd256Not_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Not(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Abs_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Abs(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsFinite_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsFinite(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsInfinity_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNaN_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNaN(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegative_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegative(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNegativeInfinity_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNegativeInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsNormal_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsNormal(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256IsPositiveInfinity_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.IsPositiveInfinity(*((Vector256*)a + i)); + } + [Benchmark] + public void Simd256Sign_double() + { + for (int i = 0; i < IterCount * (1); i++) + *((Vector256*)c + i) = Simd256.Sign(*((Vector256*)a + i)); + } + +#endregion + + } +} +#endif \ No newline at end of file diff --git a/src/Maths/Silk.NET.Maths.Benchmarks/SimdBenchmarkDissasm.tt b/src/Maths/Silk.NET.Maths.Benchmarks/SimdBenchmarks.tt similarity index 58% rename from src/Maths/Silk.NET.Maths.Benchmarks/SimdBenchmarkDissasm.tt rename to src/Maths/Silk.NET.Maths.Benchmarks/SimdBenchmarks.tt index 1f457499b3..57c7dc4a85 100644 --- a/src/Maths/Silk.NET.Maths.Benchmarks/SimdBenchmarkDissasm.tt +++ b/src/Maths/Silk.NET.Maths.Benchmarks/SimdBenchmarks.tt @@ -16,7 +16,7 @@ namespace Silk.NET.Maths.Benchmark { [SimpleJob(RuntimeMoniker.Net50, launchCount: 1, warmupCount: 3, targetCount: 3)] [DisassemblyDiagnoser(exportHtml: true)] - public unsafe class SIMDDisasm + public unsafe class SimdBenchmarks { const int IterCount = 30; void* a; @@ -39,9 +39,37 @@ namespace Silk.NET.Maths.Benchmark } } -<# foreach (var type in new [] { "byte", "sbyte", "ushort", "short", "uint", "int", "ulong", "long", "float", "double" }) {#> +<# foreach (var type in new [] { + "byte", + "sbyte", + "ushort", + "short", + "uint", + "int", + "ulong", + "long", + "float", + "double" }) {#> <# foreach (var bitness in new [] { 64, 128, 256 }) { #> -<# foreach (var method in new [] { "GreaterThan", "LessThan", "GreaterThanOrEqual", "LessThanOrEqual", "Add", "Subtract", "Multiply", "Divide", "Min", "Max", "Equal", "NotEqual" }) { #> + +#region Vector x Vector -> Vector <#= bitness #>-bit <#= type #> + +<# foreach (var method in new [] { + "GreaterThan", + "LessThan", + "GreaterThanOrEqual", + "LessThanOrEqual", + "Add", + "Subtract", + "Multiply", + "Divide", + "Min", + "Max", + "Equal", + "NotEqual", + "And", + "Xor", + "Or" }) { #> [Benchmark] public void Simd<#= bitness #><#= method #>_<#= type #>() { @@ -49,6 +77,32 @@ namespace Silk.NET.Maths.Benchmark *((Vector<#= bitness #><<#= type #>>*)c + i) = Simd<#= bitness #>.<#= method #>(*((Vector<#= bitness #><<#= type #>>*)a + i), *((Vector<#= bitness #><<#= type #>>*)b + i)); } <# } #> + +#endregion + +#region Vector -> Vector <#= bitness #>-bit <#= type #> + +<# foreach (var method in new [] { + "Not", + "Abs", + "IsFinite", + "IsInfinity", + "IsNaN", + "IsNegative", + "IsNegativeInfinity", + "IsNormal", + "IsPositiveInfinity", + "Sign" }) { #> + [Benchmark] + public void Simd<#= bitness #><#= method #>_<#= type #>() + { + for (int i = 0; i < IterCount * (<#= 256 / bitness #>); i++) + *((Vector<#= bitness #><<#= type #>>*)c + i) = Simd<#= bitness #>.<#= method #>(*((Vector<#= bitness #><<#= type #>>*)a + i)); + } +<# } #> + +#endregion + <# } #> <# } #> } diff --git a/src/Maths/Silk.NET.Maths.Tests/SimdTests.cs b/src/Maths/Silk.NET.Maths.Tests/SimdTests.cs index dce3971067..b06d786669 100644 --- a/src/Maths/Silk.NET.Maths.Tests/SimdTests.cs +++ b/src/Maths/Silk.NET.Maths.Tests/SimdTests.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // this file is generated by T4-template with the same name. @@ -16,9 +16,9 @@ namespace Silk.NET.Maths.Tests { internal unsafe static class SimdTestsUtils { + private static readonly Random rand = new(10); internal static void FillWithRandomData(void* ptr, int len) { - var rand = new Random(10); for (int i = 0; i < len; i++) *((byte*)ptr + i) = (byte)rand.Next(4, 12); } @@ -9020,483 +9020,3363 @@ public void Simd64_Abs_double() } } [Fact] + public void Simd64_IsFinite_byte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsFinite(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsFinite_sbyte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsFinite(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsFinite_ushort() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsFinite(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsFinite_short() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsFinite(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsFinite_uint() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsFinite(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsFinite_int() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsFinite(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsFinite_ulong() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsFinite(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsFinite_long() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsFinite(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsFinite_float() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsFinite(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsFinite_double() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsFinite(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsInfinity_byte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsInfinity_sbyte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsInfinity_ushort() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsInfinity_short() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsInfinity_uint() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsInfinity_int() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsInfinity_ulong() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsInfinity_long() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsInfinity_float() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsInfinity_double() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNaN_byte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNaN(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNaN_sbyte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNaN(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNaN_ushort() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNaN(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNaN_short() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNaN(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNaN_uint() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNaN(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNaN_int() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNaN(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNaN_ulong() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNaN(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNaN_long() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNaN(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNaN_float() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNaN(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNaN_double() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNaN(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegative_byte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegative(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegative_sbyte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegative(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegative_ushort() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegative(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegative_short() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegative(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegative_uint() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegative(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegative_int() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegative(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegative_ulong() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegative(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegative_long() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegative(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegative_float() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegative(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegative_double() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegative(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegativeInfinity_byte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegativeInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegativeInfinity_sbyte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegativeInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegativeInfinity_ushort() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegativeInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegativeInfinity_short() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegativeInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegativeInfinity_uint() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegativeInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegativeInfinity_int() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegativeInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegativeInfinity_ulong() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegativeInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegativeInfinity_long() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegativeInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegativeInfinity_float() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegativeInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNegativeInfinity_double() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNegativeInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNormal_byte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNormal(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNormal_sbyte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNormal(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNormal_ushort() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNormal(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNormal_short() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNormal(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNormal_uint() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNormal(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNormal_int() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNormal(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNormal_ulong() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNormal(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNormal_long() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNormal(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNormal_float() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNormal(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsNormal_double() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsNormal(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsPositiveInfinity_byte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsPositiveInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsPositiveInfinity_sbyte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsPositiveInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsPositiveInfinity_ushort() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsPositiveInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsPositiveInfinity_short() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsPositiveInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsPositiveInfinity_uint() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsPositiveInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsPositiveInfinity_int() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsPositiveInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsPositiveInfinity_ulong() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsPositiveInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsPositiveInfinity_long() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsPositiveInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsPositiveInfinity_float() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsPositiveInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_IsPositiveInfinity_double() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.IsPositiveInfinity(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_Sign_byte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.Sign(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_Sign_sbyte() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.Sign(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_Sign_ushort() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.Sign(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_Sign_short() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.Sign(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_Sign_uint() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.Sign(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_Sign_int() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.Sign(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_Sign_ulong() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.Sign(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_Sign_long() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.Sign(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_Sign_float() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.Sign(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd64_Sign_double() + { + Vector64 a; + SimdTestsUtils.FillWithRandomData(&a, 8); + var actual = Simd64.Sign(a); + for (int i = 0; i < Vector64.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] public void Simd128_Not_byte() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Not(a); - for (int i = 0; i < Vector128.Count; i++) + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Not(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Not_sbyte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Not(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Not_ushort() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Not(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Not_short() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Not(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Not_uint() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Not(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Not_int() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Not(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Not_ulong() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Not(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Not_long() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Not(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Not_float() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Not(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Not_double() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Not(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Abs_byte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Abs(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Abs_sbyte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Abs(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Abs_ushort() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Abs(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Abs_short() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Abs(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Abs_uint() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Abs(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Abs_int() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Abs(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Abs_ulong() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Abs(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Abs_long() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Abs(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Abs_float() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Abs(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Abs_double() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Abs(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsFinite_byte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsFinite(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsFinite_sbyte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsFinite(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsFinite_ushort() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsFinite(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsFinite_short() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsFinite(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsFinite_uint() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsFinite(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsFinite_int() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsFinite(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsFinite_ulong() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsFinite(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsFinite_long() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsFinite(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsFinite_float() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsFinite(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsFinite_double() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsFinite(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsInfinity_byte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsInfinity_sbyte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsInfinity_ushort() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsInfinity_short() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsInfinity_uint() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsInfinity_int() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsInfinity_ulong() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsInfinity_long() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsInfinity_float() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsInfinity_double() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNaN_byte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNaN(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNaN_sbyte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNaN(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNaN_ushort() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNaN(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNaN_short() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNaN(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNaN_uint() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNaN(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNaN_int() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNaN(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNaN_ulong() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNaN(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNaN_long() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNaN(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNaN_float() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNaN(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNaN_double() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNaN(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegative_byte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegative(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegative_sbyte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegative(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegative_ushort() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegative(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegative_short() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegative(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegative_uint() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegative(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegative_int() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegative(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegative_ulong() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegative(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegative_long() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegative(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegative_float() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegative(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegative_double() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegative(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegativeInfinity_byte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegativeInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegativeInfinity_sbyte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegativeInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegativeInfinity_ushort() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegativeInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegativeInfinity_short() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegativeInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegativeInfinity_uint() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegativeInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegativeInfinity_int() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegativeInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegativeInfinity_ulong() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegativeInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegativeInfinity_long() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegativeInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegativeInfinity_float() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegativeInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNegativeInfinity_double() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNegativeInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNormal_byte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNormal(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNormal_sbyte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNormal(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNormal_ushort() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNormal(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNormal_short() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNormal(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNormal_uint() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNormal(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNormal_int() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNormal(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNormal_ulong() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNormal(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNormal_long() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNormal(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNormal_float() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNormal(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsNormal_double() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsNormal(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsPositiveInfinity_byte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsPositiveInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsPositiveInfinity_sbyte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsPositiveInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsPositiveInfinity_ushort() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsPositiveInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsPositiveInfinity_short() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsPositiveInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsPositiveInfinity_uint() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsPositiveInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsPositiveInfinity_int() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsPositiveInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsPositiveInfinity_ulong() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsPositiveInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsPositiveInfinity_long() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsPositiveInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsPositiveInfinity_float() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsPositiveInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_IsPositiveInfinity_double() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.IsPositiveInfinity(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Sign_byte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Sign(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Sign_sbyte() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Sign(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Sign_ushort() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Sign(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Sign_short() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Sign(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Sign_uint() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Sign(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Sign_int() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Sign(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Sign_ulong() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Sign(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Sign_long() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Sign(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Sign_float() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Sign(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd128_Sign_double() + { + Vector128 a; + SimdTestsUtils.FillWithRandomData(&a, 16); + var actual = Simd128.Sign(a); + for (int i = 0; i < Vector128.Count; i++) + { + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Not_byte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Not(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Not_sbyte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Not(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Not_ushort() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Not(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Not_short() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Not(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Not_uint() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Not(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Not_int() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Not(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Not_ulong() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Not(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Not_long() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Not(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Not_float() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Not(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Not_double() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Not(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Not(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Abs_byte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Abs(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Abs_sbyte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Abs(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Abs_ushort() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Abs(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Abs_short() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Abs(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Abs_uint() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Abs(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Abs_int() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Abs(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Abs_ulong() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Abs(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Abs_long() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Abs(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Abs_float() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Abs(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_Abs_double() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.Abs(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.Abs(a.GetElement(i)); + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsFinite_byte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsFinite(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsFinite_sbyte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsFinite(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsFinite_ushort() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsFinite(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsFinite_short() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsFinite(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsFinite_uint() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsFinite(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsFinite_int() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsFinite(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsFinite_ulong() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsFinite(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsFinite_long() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsFinite(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsFinite_float() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsFinite(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsFinite_double() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsFinite(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsFinite(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsInfinity_byte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsInfinity(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsInfinity_sbyte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsInfinity(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsInfinity_ushort() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsInfinity(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsInfinity_short() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsInfinity(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsInfinity_uint() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsInfinity(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsInfinity_int() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsInfinity(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsInfinity_ulong() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsInfinity(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsInfinity_long() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsInfinity(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsInfinity_float() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsInfinity(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsInfinity_double() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsInfinity(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNaN_byte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNaN(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNaN_sbyte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNaN(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNaN_ushort() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNaN(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNaN_short() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNaN(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNaN_uint() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNaN(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNaN_int() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNaN(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNaN_ulong() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNaN(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNaN_long() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNaN(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNaN_float() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNaN(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNaN_double() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNaN(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNaN(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNegative_byte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegative(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNegative_sbyte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegative(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNegative_ushort() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegative(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNegative_short() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegative(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNegative_uint() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegative(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNegative_int() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegative(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNegative_ulong() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegative(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNegative_long() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegative(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNegative_float() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegative(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNegative_double() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegative(a); + for (int i = 0; i < Vector256.Count; i++) + { + var expected = Scalar.IsNegative(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; + Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + } + } + [Fact] + public void Simd256_IsNegativeInfinity_byte() + { + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegativeInfinity(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Not_sbyte() + public void Simd256_IsNegativeInfinity_sbyte() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Not(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegativeInfinity(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Not_ushort() + public void Simd256_IsNegativeInfinity_ushort() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Not(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegativeInfinity(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Not_short() + public void Simd256_IsNegativeInfinity_short() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Not(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegativeInfinity(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Not_uint() + public void Simd256_IsNegativeInfinity_uint() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Not(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegativeInfinity(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Not_int() + public void Simd256_IsNegativeInfinity_int() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Not(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegativeInfinity(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Not_ulong() + public void Simd256_IsNegativeInfinity_ulong() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Not(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegativeInfinity(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Not_long() + public void Simd256_IsNegativeInfinity_long() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Not(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegativeInfinity(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Not_float() + public void Simd256_IsNegativeInfinity_float() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Not(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegativeInfinity(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Not_double() + public void Simd256_IsNegativeInfinity_double() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Not(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNegativeInfinity(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsNegativeInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Abs_byte() + public void Simd256_IsNormal_byte() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Abs(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNormal(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Abs_sbyte() + public void Simd256_IsNormal_sbyte() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Abs(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNormal(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Abs_ushort() + public void Simd256_IsNormal_ushort() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Abs(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNormal(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Abs_short() + public void Simd256_IsNormal_short() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Abs(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNormal(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Abs_uint() + public void Simd256_IsNormal_uint() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Abs(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNormal(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Abs_int() + public void Simd256_IsNormal_int() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Abs(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNormal(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Abs_ulong() + public void Simd256_IsNormal_ulong() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Abs(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNormal(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Abs_long() + public void Simd256_IsNormal_long() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Abs(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNormal(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Abs_float() + public void Simd256_IsNormal_float() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Abs(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNormal(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd128_Abs_double() + public void Simd256_IsNormal_double() { - Vector128 a; - SimdTestsUtils.FillWithRandomData(&a, 16); - var actual = Simd128.Abs(a); - for (int i = 0; i < Vector128.Count; i++) + Vector256 a; + SimdTestsUtils.FillWithRandomData(&a, 32); + var actual = Simd256.IsNormal(a); + for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); + var expected = Scalar.IsNormal(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Not_byte() + public void Simd256_IsPositiveInfinity_byte() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Not(a); + var actual = Simd256.IsPositiveInfinity(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Not_sbyte() + public void Simd256_IsPositiveInfinity_sbyte() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Not(a); + var actual = Simd256.IsPositiveInfinity(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Not_ushort() + public void Simd256_IsPositiveInfinity_ushort() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Not(a); + var actual = Simd256.IsPositiveInfinity(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Not_short() + public void Simd256_IsPositiveInfinity_short() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Not(a); + var actual = Simd256.IsPositiveInfinity(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Not_uint() + public void Simd256_IsPositiveInfinity_uint() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Not(a); + var actual = Simd256.IsPositiveInfinity(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Not_int() + public void Simd256_IsPositiveInfinity_int() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Not(a); + var actual = Simd256.IsPositiveInfinity(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Not_ulong() + public void Simd256_IsPositiveInfinity_ulong() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Not(a); + var actual = Simd256.IsPositiveInfinity(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Not_long() + public void Simd256_IsPositiveInfinity_long() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Not(a); + var actual = Simd256.IsPositiveInfinity(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Not_float() + public void Simd256_IsPositiveInfinity_float() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Not(a); + var actual = Simd256.IsPositiveInfinity(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Not_double() + public void Simd256_IsPositiveInfinity_double() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Not(a); + var actual = Simd256.IsPositiveInfinity(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Not(a.GetElement(i)); + var expected = Scalar.IsPositiveInfinity(a.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero; Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Abs_byte() + public void Simd256_Sign_byte() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Abs(a); + var actual = Simd256.Sign(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); - Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Abs_sbyte() + public void Simd256_Sign_sbyte() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Abs(a); + var actual = Simd256.Sign(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); - Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Abs_ushort() + public void Simd256_Sign_ushort() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Abs(a); + var actual = Simd256.Sign(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); - Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Abs_short() + public void Simd256_Sign_short() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Abs(a); + var actual = Simd256.Sign(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); - Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Abs_uint() + public void Simd256_Sign_uint() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Abs(a); + var actual = Simd256.Sign(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); - Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Abs_int() + public void Simd256_Sign_int() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Abs(a); + var actual = Simd256.Sign(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); - Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Abs_ulong() + public void Simd256_Sign_ulong() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Abs(a); + var actual = Simd256.Sign(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); - Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Abs_long() + public void Simd256_Sign_long() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Abs(a); + var actual = Simd256.Sign(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); - Assert.True(expected == actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Abs_float() + public void Simd256_Sign_float() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Abs(a); + var actual = Simd256.Sign(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); - Assert.True(expected == actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i) || float.IsNaN(expected) && float.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } [Fact] - public void Simd256_Abs_double() + public void Simd256_Sign_double() { Vector256 a; SimdTestsUtils.FillWithRandomData(&a, 32); - var actual = Simd256.Abs(a); + var actual = Simd256.Sign(a); for (int i = 0; i < Vector256.Count; i++) { - var expected = Scalar.Abs(a.GetElement(i)); - Assert.True(expected == actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); + var expected = Scalar.Sign(a.GetElement(i)); + Assert.True(expected == (int)actual.GetElement(i) || double.IsNaN(expected) && double.IsNaN(actual.GetElement(i)), $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } } diff --git a/src/Maths/Silk.NET.Maths.Tests/SimdTests.tt b/src/Maths/Silk.NET.Maths.Tests/SimdTests.tt index 4cec019096..7eecee70d8 100644 --- a/src/Maths/Silk.NET.Maths.Tests/SimdTests.tt +++ b/src/Maths/Silk.NET.Maths.Tests/SimdTests.tt @@ -16,9 +16,9 @@ namespace Silk.NET.Maths.Tests { internal unsafe static class SimdTestsUtils { + private static readonly Random rand = new(10); internal static void FillWithRandomData(void* ptr, int len) { - var rand = new Random(10); for (int i = 0; i < len; i++) *((byte*)ptr + i) = (byte)rand.Next(4, 12); } @@ -83,7 +83,7 @@ namespace Silk.NET.Maths.Tests public unsafe class SimdTests_Vector_Vector { <# foreach (var bitness in new [] { 64, 128, 256 }) { #> -<# foreach (var method in new [] { "Not", "Abs" }) { #> +<# foreach (var method in new [] { "Not", "Abs", "IsFinite", "IsInfinity", "IsNaN", "IsNegative", "IsNegativeInfinity", "IsNormal", "IsPositiveInfinity", "Sign" }) { #> <# foreach (var type in new [] { "byte", "sbyte", "ushort", "short", "uint", "int", "ulong", "long", "float", "double" }) {#> [Fact] public void Simd<#= bitness #>_<#= method #>_<#= type #>() @@ -93,9 +93,10 @@ namespace Silk.NET.Maths.Tests var actual = Simd<#= bitness #>.<#= method #>(a); for (int i = 0; i < Vector<#= bitness #><<#= type #>>.Count; i++) { - var expected = Scalar.<#= method #>(a.GetElement(i)); + var expected = Scalar.<#= method #>(a.GetElement(i))<#= method is "Not" or "Abs" or "Sign" ? "" : $" ? Scalar<{type}>.AllBitsSet : Scalar<{type}>.Zero" #>; <# var nanProcess = type is "float" or "double" ? $" || {type}.IsNaN(expected) && {type}.IsNaN(actual.GetElement(i))" : ""; #> - Assert.True(expected == actual.GetElement(i)<#= nanProcess #>, $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); +<# var cast = method is "Sign" ? "(int)" : ""; #> + Assert.True(expected == <#= cast #>actual.GetElement(i)<#= nanProcess #>, $"\nId {i}\na[i]: {a.GetElement(i)}\nActual[i]: {actual.GetElement(i)}\nExpected: {expected}"); } } <# } #> diff --git a/src/Maths/Silk.NET.Maths/Scalar.BaseOps.cs b/src/Maths/Silk.NET.Maths/Scalar.BaseOps.cs index e9266dc3c8..e2a93f0fd8 100644 --- a/src/Maths/Silk.NET.Maths/Scalar.BaseOps.cs +++ b/src/Maths/Silk.NET.Maths/Scalar.BaseOps.cs @@ -360,9 +360,9 @@ static bool Decimal(T f) [MethodImpl(MaxOpt)] static bool SByte(T f) { - if (typeof(T) == typeof(int)) + if (typeof(T) == typeof(sbyte)) { - return (int) (object) f < 0; + return (sbyte) (object) f < 0; } return BigInteger(f); @@ -455,6 +455,17 @@ static bool Other(T f) } } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static unsafe int SingleToInt32Bits(float value) + { +#if NETSTANDARD2_1_OR_GREATER + return BitConverter.SingleToInt32Bits(value); +#else + // https://source.dot.net/#System.Private.CoreLib/BitConverter.cs,808 + return *((int*)&value); +#endif + } + /// /// Determines whether the specified value is normal. /// @@ -476,7 +487,13 @@ static bool Float(T f) { if (typeof(T) == typeof(float)) { - return IsNormal((float) (object) f); +#if NETSTANDARD2_1_OR_GREATER + return float.IsNormal((float) (object) f); +#else + int bits = SingleToInt32Bits((float) (object) f); + bits &= 0x7FFFFFFF; + return (bits < 0x7F800000) && (bits != 0) && ((bits & 0x7F800000) != 0); +#endif } return Double(f); @@ -487,7 +504,13 @@ static bool Double(T f) { if (typeof(T) == typeof(double)) { - return IsNormal((double) (object) f); +#if NETSTANDARD2_1_OR_GREATER + return double.IsNormal((double) (object) f); +#else + long bits = BitConverter.DoubleToInt64Bits((double) (object) f); + bits &= 0x7FFFFFFFFFFFFFFF; + return (bits < 0x7FF0000000000000) && (bits != 0) && ((bits & 0x7FF0000000000000) != 0); +#endif } return Other(f); diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd128.Constants.cs b/src/Maths/Silk.NET.Maths/Simd/Simd128.Constants.cs index 3175cbbf75..4ab7ec63a6 100644 --- a/src/Maths/Silk.NET.Maths/Simd/Simd128.Constants.cs +++ b/src/Maths/Silk.NET.Maths/Simd/Simd128.Constants.cs @@ -155,5 +155,13 @@ static Simd128() #endif } } + + partial class Simd128 + { + private static readonly Vector128 DoubleUnsignedMask = Vector128.Create(0x7FFFFFFFFFFFFFFF); + private static readonly Vector128 DoubleFiniteThreshold = Vector128.Create(0x7FF0000000000000); + private static readonly Vector128 SingleUnsignedMask = Vector128.Create(0x7FFFFFFF); + private static readonly Vector128 SingleFiniteThreshold = Vector128.Create(0x7F800000); + } } #endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd128.IsFinite.cs b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsFinite.cs new file mode 100644 index 0000000000..b77fe138c1 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsFinite.cs @@ -0,0 +1,80 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd128 + { + /// + /// Performs hardware-accelerated IsFinite on 128-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector128 IsFinite(Vector128 vector) where T : unmanaged + { + return Single(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Single(Vector128 vector) + { + if (typeof(T) == typeof(float)) + { + return LessThan(And(vector.AsInt32(), SingleUnsignedMask), SingleFiniteThreshold).As(); + } + + return Double(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Double(Vector128 vector) + { + if (typeof(T) == typeof(double)) + { + return LessThan(And(vector.AsInt64(), DoubleUnsignedMask), DoubleFiniteThreshold).As(); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Integer(Vector128 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd128.AllBitsSet; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Other(Vector128 vector) + { + var vec = Vector128.Zero; + for (int i = 0; i < Vector128.Count; i++) + { + vec.WithElement(i, Scalar.IsFinite(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd128.IsInfinity.cs b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsInfinity.cs new file mode 100644 index 0000000000..2d83aa1d66 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsInfinity.cs @@ -0,0 +1,80 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd128 + { + /// + /// Performs hardware-accelerated IsInfinity on 128-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector128 IsInfinity(Vector128 vector) where T : unmanaged + { + return Single(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Single(Vector128 vector) + { + if (typeof(T) == typeof(float)) + { + return Equal(And(vector.AsInt32(), SingleUnsignedMask), SingleFiniteThreshold).As(); + } + + return Double(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Double(Vector128 vector) + { + if (typeof(T) == typeof(double)) + { + return Equal(And(vector.AsInt64(), DoubleUnsignedMask), DoubleFiniteThreshold).As(); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Integer(Vector128 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd128.Zero; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Other(Vector128 vector) + { + var vec = Vector128.Zero; + for (int i = 0; i < Vector128.Count; i++) + { + vec.WithElement(i, Scalar.IsInfinity(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd128.IsNaN.cs b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsNaN.cs new file mode 100644 index 0000000000..64fba3daae --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsNaN.cs @@ -0,0 +1,69 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd128 + { + /// + /// Performs hardware-accelerated IsNaN on 128-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector128 IsNaN(Vector128 vector) where T : unmanaged + { + return SingleOrDouble(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 SingleOrDouble(Vector128 vector) + { + if (typeof(T) == typeof(float) || typeof(T) == typeof(double)) + { + return NotEqual(vector, vector); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Integer(Vector128 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd128.Zero; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Other(Vector128 vector) + { + var vec = Vector128.Zero; + for (int i = 0; i < Vector128.Count; i++) + { + vec.WithElement(i, Scalar.IsNaN(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd128.IsNegative.cs b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsNegative.cs new file mode 100644 index 0000000000..94f98686ab --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsNegative.cs @@ -0,0 +1,58 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd128 + { + /// + /// Performs hardware-accelerated IsNegative on 128-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector128 IsNegative(Vector128 vector) where T : unmanaged + { + return Single(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Single(Vector128 vector) + { + if (typeof(T) == typeof(float)) + { + return LessThan(vector.AsInt32(), Simd128.Zero).As(); + } + + return Double(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Double(Vector128 vector) + { + if (typeof(T) == typeof(double)) + { + return LessThan(vector.AsInt64(), Simd128.Zero).As(); + } + + return Other(vector); + } + + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Other(Vector128 vector) + { + return LessThan(vector, Simd128.Zero); + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd128.IsNegativeInfinity.cs b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsNegativeInfinity.cs new file mode 100644 index 0000000000..9cf37da886 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsNegativeInfinity.cs @@ -0,0 +1,69 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd128 + { + /// + /// Performs hardware-accelerated IsNegativeInfinity on 128-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector128 IsNegativeInfinity(Vector128 vector) where T : unmanaged + { + return SingleOrDouble(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 SingleOrDouble(Vector128 vector) + { + if (typeof(T) == typeof(float) || typeof(T) == typeof(double)) + { + return Equal(vector, Simd128.NegativeInfinity); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Integer(Vector128 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd128.Zero; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Other(Vector128 vector) + { + var vec = Vector128.Zero; + for (int i = 0; i < Vector128.Count; i++) + { + vec.WithElement(i, Scalar.IsNegativeInfinity(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd128.IsNormal.cs b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsNormal.cs new file mode 100644 index 0000000000..08fa71f0b3 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsNormal.cs @@ -0,0 +1,131 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd128 + { + /// + /// Performs hardware-accelerated IsNormal on 128-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector128 IsNormal(Vector128 vector) where T : unmanaged + { + return Single(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Single(Vector128 vector) + { + if (typeof(T) == typeof(float)) + { + /* + https://source.dot.net/#System.Private.CoreLib/Single.cs,121 + int bits = BitConverter.SingleToInt32Bits(f); + bits &= 0x7FFFFFFF; + return (bits < 0x7F800000) && (bits != 0) && ((bits & 0x7F800000) != 0); + */ + var bits = And(vector.AsInt32(), SingleUnsignedMask); + return + // we exclude bits != 0 + // because we don't have short-circuited "and" in simd, + // so doing this is useless since bits != 0 is a weaker + // statement than (bits & 0x7F800000) != 0. + // (bits < 0x7F800000) && ((bits & 0x7F800000) != 0) + And( + // bits < 0x7F800000 + LessThan(bits, SingleFiniteThreshold), + // (bits & 0x7F800000) != 0 + NotEqual( + // bits & 0x7F800000 + And( + bits, + SingleFiniteThreshold + ), + Simd128.Zero + ) + ).As(); + } + + return Double(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Double(Vector128 vector) + { + if (typeof(T) == typeof(double)) + { + /* + https://source.dot.net/#System.Private.CoreLib/Double.cs,125 + long bits = BitConverter.DoubleToInt64Bits(d); + bits &= 0x7FFFFFFFFFFFFFFF; + return (bits < 0x7FF0000000000000) && (bits != 0) && ((bits & 0x7FF0000000000000) != 0); + */ + var bits = And(vector.AsInt64(), DoubleUnsignedMask); + return + // we exclude bits != 0 + // because we don't have short-circuited "and" in simd, + // so doing this is useless since bits != 0 is a weaker + // statement than (bits & 0x7FF0000000000000) != 0. + // (bits < 0x7FF0000000000000) && ((bits & 0x7FF0000000000000) != 0) + And( + // bits < 0x7FF0000000000000 + LessThan(bits, DoubleFiniteThreshold), + // (bits & 0x7FF0000000000000) != 0 + NotEqual( + // bits & 0x7FF0000000000000 + And( + bits, + DoubleFiniteThreshold + ), + Simd128.Zero + ) + ).As(); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Integer(Vector128 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd128.AllBitsSet; + } + + return Other(vector); + } + + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Other(Vector128 vector) + { + var vec = Vector128.Zero; + for (int i = 0; i < Vector128.Count; i++) + { + vec.WithElement(i, Scalar.IsNormal(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd128.IsPositiveInfinity.cs b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsPositiveInfinity.cs new file mode 100644 index 0000000000..caa2b1458f --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd128.IsPositiveInfinity.cs @@ -0,0 +1,69 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd128 + { + /// + /// Performs hardware-accelerated IsPositiveInfinity on 128-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector128 IsPositiveInfinity(Vector128 vector) where T : unmanaged + { + return SingleOrDouble(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 SingleOrDouble(Vector128 vector) + { + if (typeof(T) == typeof(float) || typeof(T) == typeof(double)) + { + return Equal(vector, Simd128.PositiveInfinity); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Integer(Vector128 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd128.Zero; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Other(Vector128 vector) + { + var vec = Vector128.Zero; + for (int i = 0; i < Vector128.Count; i++) + { + vec.WithElement(i, Scalar.IsPositiveInfinity(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd128.Sign.cs b/src/Maths/Silk.NET.Maths/Simd/Simd128.Sign.cs new file mode 100644 index 0000000000..57071fa730 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd128.Sign.cs @@ -0,0 +1,112 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd128 + { + /// + /// Performs hardware-accelerated Sign on 128-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector128 Sign(Vector128 vector) where T : unmanaged + { + return SignedNumber(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 SignedNumber(Vector128 vector) + { + if (typeof(T) == typeof(float) + || typeof(T) == typeof(double) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(short) + || typeof(T) == typeof(int) + || typeof(T) == typeof(long)) + { + // https://source.dot.net/#System.Private.CoreLib/Math.cs,1361 + /* + if (value < 0) + { + return -1; + } + else if (value > 0) + { + return 1; + } + else if (value == 0) + { + return 0; + } + + is the same as + + (value < 0 & -1) + | (value > 0 & 1) + + Note 0, not IsNegative + */ + return + // (value < 0 & -1) | (value > 0 & 1) + Or( + // value < 0 & -1 + And(LessThan(vector, Simd128.Zero), Simd128.MinusOne), + + // value > 0 & 1 + And(GreaterThan(vector, Simd128.Zero), Simd128.One) + ); + } + + return UnsignedNumber(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 UnsignedNumber(Vector128 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(ulong)) + { + // no need to have the case < 0, since it is always false. + return + And( + GreaterThan(vector, Simd128.Zero), + Simd128.One + ); + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector128 Other(Vector128 vector) + { + var vec = Vector128.Zero; + for (int i = 0; i < Vector128.Count; i++) + { + vec.WithElement(i, + Scalar.GreaterThan(vector.GetElement(i), Scalar.Zero) + ? Scalar.One + : ( + Scalar.LessThan(vector.GetElement(i), Scalar.Zero) + ? Scalar.MinusOne + : Scalar.Zero + )); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd256.Constants.cs b/src/Maths/Silk.NET.Maths/Simd/Simd256.Constants.cs index 3316bd8505..d3c0a5a4b7 100644 --- a/src/Maths/Silk.NET.Maths/Simd/Simd256.Constants.cs +++ b/src/Maths/Silk.NET.Maths/Simd/Simd256.Constants.cs @@ -145,5 +145,13 @@ static Simd256() #endif } } + + partial class Simd256 + { + private static readonly Vector256 DoubleUnsignedMask = Vector256.Create(0x7FFFFFFFFFFFFFFF); + private static readonly Vector256 DoubleFiniteThreshold = Vector256.Create(0x7FF0000000000000); + private static readonly Vector256 SingleUnsignedMask = Vector256.Create(0x7FFFFFFF); + private static readonly Vector256 SingleFiniteThreshold = Vector256.Create(0x7F800000); + } } #endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd256.IsFinite.cs b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsFinite.cs new file mode 100644 index 0000000000..b2b8ed6b5f --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsFinite.cs @@ -0,0 +1,80 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd256 + { + /// + /// Performs hardware-accelerated IsFinite on 256-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector256 IsFinite(Vector256 vector) where T : unmanaged + { + return Single(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Single(Vector256 vector) + { + if (typeof(T) == typeof(float)) + { + return LessThan(And(vector.AsInt32(), SingleUnsignedMask), SingleFiniteThreshold).As(); + } + + return Double(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Double(Vector256 vector) + { + if (typeof(T) == typeof(double)) + { + return LessThan(And(vector.AsInt64(), DoubleUnsignedMask), DoubleFiniteThreshold).As(); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Integer(Vector256 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd256.AllBitsSet; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Other(Vector256 vector) + { + var vec = Vector256.Zero; + for (int i = 0; i < Vector256.Count; i++) + { + vec.WithElement(i, Scalar.IsFinite(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd256.IsInfinity.cs b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsInfinity.cs new file mode 100644 index 0000000000..0b1601c1f1 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsInfinity.cs @@ -0,0 +1,80 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd256 + { + /// + /// Performs hardware-accelerated IsInfinity on 256-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector256 IsInfinity(Vector256 vector) where T : unmanaged + { + return Single(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Single(Vector256 vector) + { + if (typeof(T) == typeof(float)) + { + return Equal(And(vector.AsInt32(), SingleUnsignedMask), SingleFiniteThreshold).As(); + } + + return Double(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Double(Vector256 vector) + { + if (typeof(T) == typeof(double)) + { + return Equal(And(vector.AsInt64(), DoubleUnsignedMask), DoubleFiniteThreshold).As(); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Integer(Vector256 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd256.Zero; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Other(Vector256 vector) + { + var vec = Vector256.Zero; + for (int i = 0; i < Vector256.Count; i++) + { + vec.WithElement(i, Scalar.IsInfinity(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd256.IsNaN.cs b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsNaN.cs new file mode 100644 index 0000000000..65b3d2c389 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsNaN.cs @@ -0,0 +1,69 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd256 + { + /// + /// Performs hardware-accelerated IsNaN on 256-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector256 IsNaN(Vector256 vector) where T : unmanaged + { + return SingleOrDouble(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 SingleOrDouble(Vector256 vector) + { + if (typeof(T) == typeof(float) || typeof(T) == typeof(double)) + { + return NotEqual(vector, vector); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Integer(Vector256 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd256.Zero; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Other(Vector256 vector) + { + var vec = Vector256.Zero; + for (int i = 0; i < Vector256.Count; i++) + { + vec.WithElement(i, Scalar.IsNaN(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd256.IsNegative.cs b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsNegative.cs new file mode 100644 index 0000000000..c766a0d442 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsNegative.cs @@ -0,0 +1,58 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd256 + { + /// + /// Performs hardware-accelerated IsNegative on 256-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector256 IsNegative(Vector256 vector) where T : unmanaged + { + return Single(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Single(Vector256 vector) + { + if (typeof(T) == typeof(float)) + { + return LessThan(vector.AsInt32(), Simd256.Zero).As(); + } + + return Double(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Double(Vector256 vector) + { + if (typeof(T) == typeof(double)) + { + return LessThan(vector.AsInt64(), Simd256.Zero).As(); + } + + return Other(vector); + } + + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Other(Vector256 vector) + { + return LessThan(vector, Simd256.Zero); + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd256.IsNegativeInfinity.cs b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsNegativeInfinity.cs new file mode 100644 index 0000000000..d58527589d --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsNegativeInfinity.cs @@ -0,0 +1,69 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd256 + { + /// + /// Performs hardware-accelerated IsNegativeInfinity on 256-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector256 IsNegativeInfinity(Vector256 vector) where T : unmanaged + { + return SingleOrDouble(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 SingleOrDouble(Vector256 vector) + { + if (typeof(T) == typeof(float) || typeof(T) == typeof(double)) + { + return Equal(vector, Simd256.NegativeInfinity); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Integer(Vector256 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd256.Zero; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Other(Vector256 vector) + { + var vec = Vector256.Zero; + for (int i = 0; i < Vector256.Count; i++) + { + vec.WithElement(i, Scalar.IsNegativeInfinity(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd256.IsNormal.cs b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsNormal.cs new file mode 100644 index 0000000000..1200a52cb7 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsNormal.cs @@ -0,0 +1,131 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd256 + { + /// + /// Performs hardware-accelerated IsNormal on 256-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector256 IsNormal(Vector256 vector) where T : unmanaged + { + return Single(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Single(Vector256 vector) + { + if (typeof(T) == typeof(float)) + { + /* + https://source.dot.net/#System.Private.CoreLib/Single.cs,121 + int bits = BitConverter.SingleToInt32Bits(f); + bits &= 0x7FFFFFFF; + return (bits < 0x7F800000) && (bits != 0) && ((bits & 0x7F800000) != 0); + */ + var bits = And(vector.AsInt32(), SingleUnsignedMask); + return + // we exclude bits != 0 + // because we don't have short-circuited "and" in simd, + // so doing this is useless since bits != 0 is a weaker + // statement than (bits & 0x7F800000) != 0. + // (bits < 0x7F800000) && ((bits & 0x7F800000) != 0) + And( + // bits < 0x7F800000 + LessThan(bits, SingleFiniteThreshold), + // (bits & 0x7F800000) != 0 + NotEqual( + // bits & 0x7F800000 + And( + bits, + SingleFiniteThreshold + ), + Simd256.Zero + ) + ).As(); + } + + return Double(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Double(Vector256 vector) + { + if (typeof(T) == typeof(double)) + { + /* + https://source.dot.net/#System.Private.CoreLib/Double.cs,125 + long bits = BitConverter.DoubleToInt64Bits(d); + bits &= 0x7FFFFFFFFFFFFFFF; + return (bits < 0x7FF0000000000000) && (bits != 0) && ((bits & 0x7FF0000000000000) != 0); + */ + var bits = And(vector.AsInt64(), DoubleUnsignedMask); + return + // we exclude bits != 0 + // because we don't have short-circuited "and" in simd, + // so doing this is useless since bits != 0 is a weaker + // statement than (bits & 0x7FF0000000000000) != 0. + // (bits < 0x7FF0000000000000) && ((bits & 0x7FF0000000000000) != 0) + And( + // bits < 0x7FF0000000000000 + LessThan(bits, DoubleFiniteThreshold), + // (bits & 0x7FF0000000000000) != 0 + NotEqual( + // bits & 0x7FF0000000000000 + And( + bits, + DoubleFiniteThreshold + ), + Simd256.Zero + ) + ).As(); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Integer(Vector256 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd256.AllBitsSet; + } + + return Other(vector); + } + + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Other(Vector256 vector) + { + var vec = Vector256.Zero; + for (int i = 0; i < Vector256.Count; i++) + { + vec.WithElement(i, Scalar.IsNormal(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd256.IsPositiveInfinity.cs b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsPositiveInfinity.cs new file mode 100644 index 0000000000..e3f083b250 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd256.IsPositiveInfinity.cs @@ -0,0 +1,69 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd256 + { + /// + /// Performs hardware-accelerated IsPositiveInfinity on 256-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector256 IsPositiveInfinity(Vector256 vector) where T : unmanaged + { + return SingleOrDouble(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 SingleOrDouble(Vector256 vector) + { + if (typeof(T) == typeof(float) || typeof(T) == typeof(double)) + { + return Equal(vector, Simd256.PositiveInfinity); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Integer(Vector256 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd256.Zero; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Other(Vector256 vector) + { + var vec = Vector256.Zero; + for (int i = 0; i < Vector256.Count; i++) + { + vec.WithElement(i, Scalar.IsPositiveInfinity(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd256.Sign.cs b/src/Maths/Silk.NET.Maths/Simd/Simd256.Sign.cs new file mode 100644 index 0000000000..d20eda4a7c --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd256.Sign.cs @@ -0,0 +1,112 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd256 + { + /// + /// Performs hardware-accelerated Sign on 256-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector256 Sign(Vector256 vector) where T : unmanaged + { + return SignedNumber(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 SignedNumber(Vector256 vector) + { + if (typeof(T) == typeof(float) + || typeof(T) == typeof(double) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(short) + || typeof(T) == typeof(int) + || typeof(T) == typeof(long)) + { + // https://source.dot.net/#System.Private.CoreLib/Math.cs,1361 + /* + if (value < 0) + { + return -1; + } + else if (value > 0) + { + return 1; + } + else if (value == 0) + { + return 0; + } + + is the same as + + (value < 0 & -1) + | (value > 0 & 1) + + Note 0, not IsNegative + */ + return + // (value < 0 & -1) | (value > 0 & 1) + Or( + // value < 0 & -1 + And(LessThan(vector, Simd256.Zero), Simd256.MinusOne), + + // value > 0 & 1 + And(GreaterThan(vector, Simd256.Zero), Simd256.One) + ); + } + + return UnsignedNumber(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 UnsignedNumber(Vector256 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(ulong)) + { + // no need to have the case < 0, since it is always false. + return + And( + GreaterThan(vector, Simd256.Zero), + Simd256.One + ); + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector256 Other(Vector256 vector) + { + var vec = Vector256.Zero; + for (int i = 0; i < Vector256.Count; i++) + { + vec.WithElement(i, + Scalar.GreaterThan(vector.GetElement(i), Scalar.Zero) + ? Scalar.One + : ( + Scalar.LessThan(vector.GetElement(i), Scalar.Zero) + ? Scalar.MinusOne + : Scalar.Zero + )); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd64.Constants.cs b/src/Maths/Silk.NET.Maths/Simd/Simd64.Constants.cs index fa735ad141..5e19560629 100644 --- a/src/Maths/Silk.NET.Maths/Simd/Simd64.Constants.cs +++ b/src/Maths/Silk.NET.Maths/Simd/Simd64.Constants.cs @@ -149,5 +149,13 @@ static Simd64() #endif } } + + partial class Simd64 + { + private static readonly Vector64 DoubleUnsignedMask = Vector64.Create(0x7FFFFFFFFFFFFFFF); + private static readonly Vector64 DoubleFiniteThreshold = Vector64.Create(0x7FF0000000000000); + private static readonly Vector64 SingleUnsignedMask = Vector64.Create(0x7FFFFFFF); + private static readonly Vector64 SingleFiniteThreshold = Vector64.Create(0x7F800000); + } } #endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd64.IsFinite.cs b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsFinite.cs new file mode 100644 index 0000000000..fe2571733f --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsFinite.cs @@ -0,0 +1,80 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd64 + { + /// + /// Performs hardware-accelerated IsFinite on 64-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector64 IsFinite(Vector64 vector) where T : unmanaged + { + return Single(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Single(Vector64 vector) + { + if (typeof(T) == typeof(float)) + { + return LessThan(And(vector.AsInt32(), SingleUnsignedMask), SingleFiniteThreshold).As(); + } + + return Double(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Double(Vector64 vector) + { + if (typeof(T) == typeof(double)) + { + return LessThan(And(vector.AsInt64(), DoubleUnsignedMask), DoubleFiniteThreshold).As(); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Integer(Vector64 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd64.AllBitsSet; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Other(Vector64 vector) + { + var vec = Vector64.Zero; + for (int i = 0; i < Vector64.Count; i++) + { + vec.WithElement(i, Scalar.IsFinite(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd64.IsInfinity.cs b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsInfinity.cs new file mode 100644 index 0000000000..d784ac6a00 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsInfinity.cs @@ -0,0 +1,80 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd64 + { + /// + /// Performs hardware-accelerated IsInfinity on 64-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector64 IsInfinity(Vector64 vector) where T : unmanaged + { + return Single(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Single(Vector64 vector) + { + if (typeof(T) == typeof(float)) + { + return Equal(And(vector.AsInt32(), SingleUnsignedMask), SingleFiniteThreshold).As(); + } + + return Double(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Double(Vector64 vector) + { + if (typeof(T) == typeof(double)) + { + return Equal(And(vector.AsInt64(), DoubleUnsignedMask), DoubleFiniteThreshold).As(); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Integer(Vector64 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd64.Zero; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Other(Vector64 vector) + { + var vec = Vector64.Zero; + for (int i = 0; i < Vector64.Count; i++) + { + vec.WithElement(i, Scalar.IsInfinity(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd64.IsNaN.cs b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsNaN.cs new file mode 100644 index 0000000000..b20ccaf1af --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsNaN.cs @@ -0,0 +1,69 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd64 + { + /// + /// Performs hardware-accelerated IsNaN on 64-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector64 IsNaN(Vector64 vector) where T : unmanaged + { + return SingleOrDouble(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 SingleOrDouble(Vector64 vector) + { + if (typeof(T) == typeof(float) || typeof(T) == typeof(double)) + { + return NotEqual(vector, vector); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Integer(Vector64 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd64.Zero; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Other(Vector64 vector) + { + var vec = Vector64.Zero; + for (int i = 0; i < Vector64.Count; i++) + { + vec.WithElement(i, Scalar.IsNaN(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd64.IsNegative.cs b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsNegative.cs new file mode 100644 index 0000000000..a0daa9030a --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsNegative.cs @@ -0,0 +1,58 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd64 + { + /// + /// Performs hardware-accelerated IsNegative on 64-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector64 IsNegative(Vector64 vector) where T : unmanaged + { + return Single(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Single(Vector64 vector) + { + if (typeof(T) == typeof(float)) + { + return LessThan(vector.AsInt32(), Simd64.Zero).As(); + } + + return Double(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Double(Vector64 vector) + { + if (typeof(T) == typeof(double)) + { + return LessThan(vector.AsInt64(), Simd64.Zero).As(); + } + + return Other(vector); + } + + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Other(Vector64 vector) + { + return LessThan(vector, Simd64.Zero); + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd64.IsNegativeInfinity.cs b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsNegativeInfinity.cs new file mode 100644 index 0000000000..429f98a0b6 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsNegativeInfinity.cs @@ -0,0 +1,69 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd64 + { + /// + /// Performs hardware-accelerated IsNegativeInfinity on 64-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector64 IsNegativeInfinity(Vector64 vector) where T : unmanaged + { + return SingleOrDouble(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 SingleOrDouble(Vector64 vector) + { + if (typeof(T) == typeof(float) || typeof(T) == typeof(double)) + { + return Equal(vector, Simd64.NegativeInfinity); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Integer(Vector64 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd64.Zero; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Other(Vector64 vector) + { + var vec = Vector64.Zero; + for (int i = 0; i < Vector64.Count; i++) + { + vec.WithElement(i, Scalar.IsNegativeInfinity(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd64.IsNormal.cs b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsNormal.cs new file mode 100644 index 0000000000..bcd5de8429 --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsNormal.cs @@ -0,0 +1,131 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd64 + { + /// + /// Performs hardware-accelerated IsNormal on 64-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector64 IsNormal(Vector64 vector) where T : unmanaged + { + return Single(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Single(Vector64 vector) + { + if (typeof(T) == typeof(float)) + { + /* + https://source.dot.net/#System.Private.CoreLib/Single.cs,121 + int bits = BitConverter.SingleToInt32Bits(f); + bits &= 0x7FFFFFFF; + return (bits < 0x7F800000) && (bits != 0) && ((bits & 0x7F800000) != 0); + */ + var bits = And(vector.AsInt32(), SingleUnsignedMask); + return + // we exclude bits != 0 + // because we don't have short-circuited "and" in simd, + // so doing this is useless since bits != 0 is a weaker + // statement than (bits & 0x7F800000) != 0. + // (bits < 0x7F800000) && ((bits & 0x7F800000) != 0) + And( + // bits < 0x7F800000 + LessThan(bits, SingleFiniteThreshold), + // (bits & 0x7F800000) != 0 + NotEqual( + // bits & 0x7F800000 + And( + bits, + SingleFiniteThreshold + ), + Simd64.Zero + ) + ).As(); + } + + return Double(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Double(Vector64 vector) + { + if (typeof(T) == typeof(double)) + { + /* + https://source.dot.net/#System.Private.CoreLib/Double.cs,125 + long bits = BitConverter.DoubleToInt64Bits(d); + bits &= 0x7FFFFFFFFFFFFFFF; + return (bits < 0x7FF0000000000000) && (bits != 0) && ((bits & 0x7FF0000000000000) != 0); + */ + var bits = And(vector.AsInt64(), DoubleUnsignedMask); + return + // we exclude bits != 0 + // because we don't have short-circuited "and" in simd, + // so doing this is useless since bits != 0 is a weaker + // statement than (bits & 0x7FF0000000000000) != 0. + // (bits < 0x7FF0000000000000) && ((bits & 0x7FF0000000000000) != 0) + And( + // bits < 0x7FF0000000000000 + LessThan(bits, DoubleFiniteThreshold), + // (bits & 0x7FF0000000000000) != 0 + NotEqual( + // bits & 0x7FF0000000000000 + And( + bits, + DoubleFiniteThreshold + ), + Simd64.Zero + ) + ).As(); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Integer(Vector64 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd64.AllBitsSet; + } + + return Other(vector); + } + + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Other(Vector64 vector) + { + var vec = Vector64.Zero; + for (int i = 0; i < Vector64.Count; i++) + { + vec.WithElement(i, Scalar.IsNormal(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd64.IsPositiveInfinity.cs b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsPositiveInfinity.cs new file mode 100644 index 0000000000..68fe4ab05a --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd64.IsPositiveInfinity.cs @@ -0,0 +1,69 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd64 + { + /// + /// Performs hardware-accelerated IsPositiveInfinity on 64-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector64 IsPositiveInfinity(Vector64 vector) where T : unmanaged + { + return SingleOrDouble(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 SingleOrDouble(Vector64 vector) + { + if (typeof(T) == typeof(float) || typeof(T) == typeof(double)) + { + return Equal(vector, Simd64.PositiveInfinity); + } + + return Integer(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Integer(Vector64 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(short) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(int) + || typeof(T) == typeof(ulong) + || typeof(T) == typeof(long)) + { + return Simd64.Zero; + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Other(Vector64 vector) + { + var vec = Vector64.Zero; + for (int i = 0; i < Vector64.Count; i++) + { + vec.WithElement(i, Scalar.IsPositiveInfinity(vector.GetElement(i)) ? Scalar.AllBitsSet : Scalar.Zero); + } + return vec; + } + } + } +} +#endif diff --git a/src/Maths/Silk.NET.Maths/Simd/Simd64.Sign.cs b/src/Maths/Silk.NET.Maths/Simd/Simd64.Sign.cs new file mode 100644 index 0000000000..4ef7cb31ff --- /dev/null +++ b/src/Maths/Silk.NET.Maths/Simd/Simd64.Sign.cs @@ -0,0 +1,112 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if INTRINSICS +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +#if SSE +using System.Runtime.Intrinsics.X86; +#endif +#if AdvSIMD +using System.Runtime.Intrinsics.Arm; +#endif + +namespace Silk.NET.Maths +{ + public static unsafe partial class Simd64 + { + /// + /// Performs hardware-accelerated Sign on 64-bit vectors. + /// + [MethodImpl(Scalar.MaxOpt)] + public static Vector64 Sign(Vector64 vector) where T : unmanaged + { + return SignedNumber(vector); + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 SignedNumber(Vector64 vector) + { + if (typeof(T) == typeof(float) + || typeof(T) == typeof(double) + || typeof(T) == typeof(sbyte) + || typeof(T) == typeof(short) + || typeof(T) == typeof(int) + || typeof(T) == typeof(long)) + { + // https://source.dot.net/#System.Private.CoreLib/Math.cs,1361 + /* + if (value < 0) + { + return -1; + } + else if (value > 0) + { + return 1; + } + else if (value == 0) + { + return 0; + } + + is the same as + + (value < 0 & -1) + | (value > 0 & 1) + + Note 0, not IsNegative + */ + return + // (value < 0 & -1) | (value > 0 & 1) + Or( + // value < 0 & -1 + And(LessThan(vector, Simd64.Zero), Simd64.MinusOne), + + // value > 0 & 1 + And(GreaterThan(vector, Simd64.Zero), Simd64.One) + ); + } + + return UnsignedNumber(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 UnsignedNumber(Vector64 vector) + { + if (typeof(T) == typeof(byte) + || typeof(T) == typeof(ushort) + || typeof(T) == typeof(uint) + || typeof(T) == typeof(ulong)) + { + // no need to have the case < 0, since it is always false. + return + And( + GreaterThan(vector, Simd64.Zero), + Simd64.One + ); + } + + return Other(vector); + } + + [MethodImpl(Scalar.MaxOpt)] + static Vector64 Other(Vector64 vector) + { + var vec = Vector64.Zero; + for (int i = 0; i < Vector64.Count; i++) + { + vec.WithElement(i, + Scalar.GreaterThan(vector.GetElement(i), Scalar.Zero) + ? Scalar.One + : ( + Scalar.LessThan(vector.GetElement(i), Scalar.Zero) + ? Scalar.MinusOne + : Scalar.Zero + )); + } + return vec; + } + } + } +} +#endif