<Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\Vector256.cs" />
</ItemGroup>
<ItemGroup>
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Enums.cs" />
+ </ItemGroup>
+ <ItemGroup Condition="'$(Platform)' == 'amd64' OR '$(Platform)' == 'x86'">
<Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Aes.cs" />
<Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Avx.cs" />
<Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Avx2.cs" />
<Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Bmi1.cs" />
<Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Bmi2.cs" />
- <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Enums.cs" />
<Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Fma.cs" />
<Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Lzcnt.cs" />
<Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Pclmulqdq.cs" />
<Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Sse42.cs" />
<Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Ssse3.cs" />
</ItemGroup>
+ <ItemGroup Condition="'$(Platform)' != 'amd64' AND '$(Platform)' != 'x86'">
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Aes.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Avx.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Avx2.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Bmi1.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Bmi2.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Fma.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Lzcnt.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Pclmulqdq.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Popcnt.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Sse.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Sse2.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Sse3.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Sse41.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Sse42.PlatformNotSupported.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\Ssse3.PlatformNotSupported.cs" />
+ </ItemGroup>
<ItemGroup>
<Compile Include="$(BclSourcesRoot)\System\AppContext\AppContext.cs" />
<Compile Include="$(BclSourcesRoot)\System\AppContext\AppContextSwitches.cs" />
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel AES hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Aes
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey)
+ /// </summary>
+ public static Vector128<sbyte> Decrypt(Vector128<sbyte> value, Vector128<sbyte> roundKey) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey)
+ /// </summary>
+ public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey)
+ /// </summary>
+ public static Vector128<sbyte> DecryptLast(Vector128<sbyte> value, Vector128<sbyte> roundKey) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey)
+ /// </summary>
+ public static Vector128<byte> DecryptLast(Vector128<byte> value, Vector128<byte> roundKey) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey)
+ /// </summary>
+ public static Vector128<sbyte> Encrypt(Vector128<sbyte> value, Vector128<sbyte> roundKey) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey)
+ /// </summary>
+ public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey)
+ /// </summary>
+ public static Vector128<sbyte> EncryptLast(Vector128<sbyte> value, Vector128<sbyte> roundKey) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey)
+ /// </summary>
+ public static Vector128<byte> EncryptLast(Vector128<byte> value, Vector128<byte> roundKey) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_aesimc_si128 (__m128i a)
+ /// </summary>
+ public static Vector128<sbyte> InvisibleMixColumn(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_aesimc_si128 (__m128i a)
+ /// </summary>
+ public static Vector128<byte> InvisibleMixColumn(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8)
+ /// </summary>
+ public static Vector128<sbyte> KeygenAssist(Vector128<sbyte> value, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8)
+ /// </summary>
+ public static Vector128<byte> KeygenAssist(Vector128<byte> value, byte control) { throw new PlatformNotSupportedException(); }
+
+ }
+
+}
[CLSCompliant(false)]
public static class Aes
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey)
/// </summary>
- public static Vector128<sbyte> Decrypt(Vector128<sbyte> value, Vector128<sbyte> roundKey) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> Decrypt(Vector128<sbyte> value, Vector128<sbyte> roundKey) => Decrypt(value, roundKey);
/// <summary>
/// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey)
/// </summary>
- public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey) { throw new NotImplementedException(); }
+ public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey) => Decrypt(value, roundKey);
/// <summary>
/// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey)
/// </summary>
- public static Vector128<sbyte> DecryptLast(Vector128<sbyte> value, Vector128<sbyte> roundKey) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> DecryptLast(Vector128<sbyte> value, Vector128<sbyte> roundKey) => DecryptLast(value, roundKey);
/// <summary>
/// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey)
/// </summary>
- public static Vector128<byte> DecryptLast(Vector128<byte> value, Vector128<byte> roundKey) { throw new NotImplementedException(); }
+ public static Vector128<byte> DecryptLast(Vector128<byte> value, Vector128<byte> roundKey) => DecryptLast(value, roundKey);
/// <summary>
/// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey)
/// </summary>
- public static Vector128<sbyte> Encrypt(Vector128<sbyte> value, Vector128<sbyte> roundKey) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> Encrypt(Vector128<sbyte> value, Vector128<sbyte> roundKey) => Encrypt(value, roundKey);
/// <summary>
/// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey)
/// </summary>
- public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey) { throw new NotImplementedException(); }
+ public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey) => Encrypt(value, roundKey);
/// <summary>
/// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey)
/// </summary>
- public static Vector128<sbyte> EncryptLast(Vector128<sbyte> value, Vector128<sbyte> roundKey) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> EncryptLast(Vector128<sbyte> value, Vector128<sbyte> roundKey) => EncryptLast(value, roundKey);
/// <summary>
/// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey)
/// </summary>
- public static Vector128<byte> EncryptLast(Vector128<byte> value, Vector128<byte> roundKey) { throw new NotImplementedException(); }
+ public static Vector128<byte> EncryptLast(Vector128<byte> value, Vector128<byte> roundKey) => EncryptLast(value, roundKey);
/// <summary>
/// __m128i _mm_aesimc_si128 (__m128i a)
/// </summary>
- public static Vector128<sbyte> InvisibleMixColumn(Vector128<sbyte> value) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> InvisibleMixColumn(Vector128<sbyte> value) => InvisibleMixColumn(value);
/// <summary>
/// __m128i _mm_aesimc_si128 (__m128i a)
/// </summary>
- public static Vector128<byte> InvisibleMixColumn(Vector128<byte> value) { throw new NotImplementedException(); }
+ public static Vector128<byte> InvisibleMixColumn(Vector128<byte> value) => InvisibleMixColumn(value);
/// <summary>
/// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8)
/// </summary>
- public static Vector128<sbyte> KeygenAssist(Vector128<sbyte> value, byte control) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> KeygenAssist(Vector128<sbyte> value, byte control) => KeygenAssist(value, control);
/// <summary>
/// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8)
/// </summary>
- public static Vector128<byte> KeygenAssist(Vector128<byte> value, byte control) { throw new NotImplementedException(); }
+ public static Vector128<byte> KeygenAssist(Vector128<byte> value, byte control) => KeygenAssist(value, control);
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel AVX hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Avx
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// __m256 _mm256_add_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> Add(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_add_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> Add(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_addsub_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> AddSubtract(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_addsub_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> AddSubtract(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_and_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> And(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_and_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> And(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_andnot_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> AndNot(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_andnot_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> AndNot(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_blend_ps (__m256 a, __m256 b, const int imm8)
+ /// </summary>
+ public static Vector256<float> Blend(Vector256<float> left, Vector256<float> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_blend_pd (__m256d a, __m256d b, const int imm8)
+ /// </summary>
+ public static Vector256<double> Blend(Vector256<double> left, Vector256<double> right, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_blendv_ps (__m256 a, __m256 b, __m256 mask)
+ /// </summary>
+ public static Vector256<float> BlendVariable(Vector256<float> left, Vector256<float> right, Vector256<float> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_blendv_pd (__m256d a, __m256d b, __m256d mask)
+ /// </summary>
+ public static Vector256<double> BlendVariable(Vector256<double> left, Vector256<double> right, Vector256<double> mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_broadcast_ss (float const * mem_addr)
+ /// </summary>
+ public static Vector128<float> BroadcastElementToVector128(ref float source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_broadcast_ss (float const * mem_addr)
+ /// </summary>
+ public static Vector256<float> BroadcastElementToVector256(ref float source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_broadcast_sd (double const * mem_addr)
+ /// </summary>
+ public static Vector256<double> BroadcastElementToVector256(ref double source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_broadcast_ps (__m128 const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<float> BroadcastVector128ToVector256(float* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_broadcast_pd (__m128d const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<double> BroadcastVector128ToVector256(double* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_ceil_ps (__m256 a)
+ /// </summary>
+ public static Vector256<float> Ceiling(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_ceil_pd (__m256d a)
+ /// </summary>
+ public static Vector256<double> Ceiling(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmp_ps (__m128 a, __m128 b, const int imm8)
+ /// </summary>
+ public static Vector128<float> Compare(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_cmp_pd (__m128d a, __m128d b, const int imm8)
+ /// </summary>
+ public static Vector128<double> Compare(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_cmp_ps (__m256 a, __m256 b, const int imm8)
+ /// </summary>
+ public static Vector256<float> Compare(Vector256<float> left, Vector256<float> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8)
+ /// </summary>
+ public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm256_cvtpd_epi32 (__m256d a)
+ /// </summary>
+ public static Vector128<int> ConvertToVector128Int(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128 _mm256_cvtpd_ps (__m256d a)
+ /// </summary>
+ public static Vector128<float> ConvertToVector128Float(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvtps_epi32 (__m256 a)
+ /// </summary>
+ public static Vector256<int> ConvertToVector256Int(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_cvtepi32_ps (__m256i a)
+ /// </summary>
+ public static Vector256<float> ConvertToVector256Float(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_cvtps_pd (__m128 a)
+ /// </summary>
+ public static Vector256<double> ConvertToVector256Double(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_cvtepi32_pd (__m128i a)
+ /// </summary>
+ public static Vector256<double> ConvertToVector256Double(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm256_cvttpd_epi32 (__m256d a)
+ /// </summary>
+ public static Vector128<int> ConvertToVector128IntWithTruncation(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvttps_epi32 (__m256 a)
+ /// </summary>
+ public static Vector256<int> ConvertToVector256IntWithTruncation(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_div_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> Divide(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_div_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> Divide(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_dp_ps (__m256 a, __m256 b, const int imm8)
+ /// </summary>
+ public static Vector256<float> DotProduct(Vector256<float> left, Vector256<float> right, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_moveldup_ps (__m256 a)
+ /// </summary>
+ public static Vector256<float> DuplicateEvenIndexed(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_movedup_pd (__m256d a)
+ /// </summary>
+ public static Vector256<double> DuplicateEvenIndexed(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_movehdup_ps (__m256 a)
+ /// </summary>
+ public static Vector256<float> DuplicateOddIndexed(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __int8 _mm256_extract_epi8 (__m256i a, const int index)
+ /// </summary>
+ public static sbyte ExtractSbyte<T>(Vector256<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __int8 _mm256_extract_epi8 (__m256i a, const int index)
+ /// </summary>
+ public static byte ExtractByte<T>(Vector256<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __int16 _mm256_extract_epi16 (__m256i a, const int index)
+ /// </summary>
+ public static short ExtractShort<T>(Vector256<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __int16 _mm256_extract_epi16 (__m256i a, const int index)
+ /// </summary>
+ public static ushort ExtractUshort<T>(Vector256<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __int32 _mm256_extract_epi32 (__m256i a, const int index)
+ /// </summary>
+ public static int ExtractInt<T>(Vector256<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __int32 _mm256_extract_epi32 (__m256i a, const int index)
+ /// </summary>
+ public static uint ExtractUint<T>(Vector256<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __int64 _mm256_extract_epi64 (__m256i a, const int index)
+ /// </summary>
+ public static long ExtractLong<T>(Vector256<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __int64 _mm256_extract_epi64 (__m256i a, const int index)
+ /// </summary>
+ public static ulong ExtractUlong<T>(Vector256<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8)
+ /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8)
+ /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector128<T> ExtractVector128<T>(Vector256<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(byte* address, Vector256<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(sbyte* address, Vector256<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(short* address, Vector256<short> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(ushort* address, Vector256<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(int* address, Vector256<int> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(uint* address, Vector256<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(long* address, Vector256<long> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(ulong* address, Vector256<ulong> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(float* address, Vector256<float> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(double* address, Vector256<double> value, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256d _mm256_castpd128_pd256 (__m128d a)
+ /// __m256 _mm256_castps128_ps256 (__m128 a)
+ /// __m256i _mm256_castsi128_si256 (__m128i a)
+ /// </summary>
+ public static Vector256<T> ExtendToVector256<T>(Vector128<T> value) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_floor_ps (__m256 a)
+ /// </summary>
+ public static Vector256<float> Floor(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_floor_pd (__m256d a)
+ /// </summary>
+ public static Vector256<double> Floor(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm256_castpd256_pd128 (__m256d a)
+ /// __m128 _mm256_castps256_ps128 (__m256 a)
+ /// __m128i _mm256_castsi256_si128 (__m256i a)
+ /// </summary>
+ public static Vector128<T> GetLowerHalf<T>(Vector256<T> value) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_hadd_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> HorizontalAdd(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_hadd_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> HorizontalAdd(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_hsub_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> HorizontalSubtract(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_hsub_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> HorizontalSubtract(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_insert_epi8 (__m256i a, __int8 i, const int index)
+ /// </summary>
+ public static Vector256<T> InsertSbyte<T>(Vector256<T> value, sbyte data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insert_epi8 (__m256i a, __int8 i, const int index)
+ /// </summary>
+ public static Vector256<T> InsertByte<T>(Vector256<T> value, byte data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insert_epi16 (__m256i a, __int16 i, const int index)
+ /// </summary>
+ public static Vector256<T> InsertShort<T>(Vector256<T> value, short data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insert_epi16 (__m256i a, __int16 i, const int index)
+ /// </summary>
+ public static Vector256<T> InsertUshort<T>(Vector256<T> value, ushort data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insert_epi32 (__m256i a, __int32 i, const int index)
+ /// </summary>
+ public static Vector256<T> InsertInt<T>(Vector256<T> value, int data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insert_epi32 (__m256i a, __int32 i, const int index)
+ /// </summary>
+ public static Vector256<T> InsertUint<T>(Vector256<T> value, uint data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insert_epi64 (__m256i a, __int64 i, const int index)
+ /// </summary>
+ public static Vector256<T> InsertLong<T>(Vector256<T> value, long data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insert_epi64 (__m256i a, __int64 i, const int index)
+ /// </summary>
+ public static Vector256<T> InsertUlong<T>(Vector256<T> value, ulong data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8)
+ /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8)
+ /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+ /// </summary>
+ public static Vector256<T> Insert<T>(Vector256<T> value, Vector128<T> data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+ /// </summary>
+ public static unsafe Vector256<sbyte> Insert(Vector256<sbyte> value, sbyte* address, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+ /// </summary>
+ public static unsafe Vector256<byte> Insert(Vector256<byte> value, byte* address, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+ /// </summary>
+ public static unsafe Vector256<short> Insert(Vector256<short> value, short* address, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+ /// </summary>
+ public static unsafe Vector256<ushort> Insert(Vector256<ushort> value, ushort* address, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+ /// </summary>
+ public static unsafe Vector256<int> Insert(Vector256<int> value, int* address, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+ /// </summary>
+ public static unsafe Vector256<uint> Insert(Vector256<uint> value, uint* address, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+ /// </summary>
+ public static unsafe Vector256<long> Insert(Vector256<long> value, long* address, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
+ /// </summary>
+ public static unsafe Vector256<ulong> Insert(Vector256<ulong> value, ulong* address, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8)
+ /// </summary>
+ public static unsafe Vector256<float> Insert(Vector256<float> value, float* address, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8)
+ /// </summary>
+ public static unsafe Vector256<double> Insert(Vector256<double> value, double* address, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<sbyte> Load(sbyte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<byte> Load(byte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<short> Load(short* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<ushort> Load(ushort* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<int> Load(int* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<uint> Load(uint* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<long> Load(long* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<ulong> Load(ulong* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_loadu_ps (float const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<float> Load(float* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_loadu_pd (double const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<double> Load(double* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_load_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<sbyte> LoadAligned(sbyte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_load_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<byte> LoadAligned(byte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_load_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<short> LoadAligned(short* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_load_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<ushort> LoadAligned(ushort* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_load_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<int> LoadAligned(int* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_load_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<uint> LoadAligned(uint* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_load_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<long> LoadAligned(long* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_load_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<ulong> LoadAligned(ulong* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_load_ps (float const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<float> LoadAligned(float* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_load_pd (double const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<double> LoadAligned(double* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<sbyte> LoadDqu(sbyte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<byte> LoadDqu(byte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<short> LoadDqu(short* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<ushort> LoadDqu(ushort* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<int> LoadDqu(int* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<uint> LoadDqu(uint* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<long> LoadDqu(long* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
+ /// </summary>
+ public static unsafe Vector256<ulong> LoadDqu(ulong* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_maskload_pd (double const * mem_addr, __m128i mask)
+ /// </summary>
+ public static unsafe Vector128<float> MaskLoad(float* address, Vector128<uint> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_maskload_pd (double const * mem_addr, __m128i mask)
+ /// </summary>
+ public static unsafe Vector128<double> MaskLoad(double* address, Vector128<ulong> mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_maskload_ps (float const * mem_addr, __m256i mask)
+ /// </summary>
+ public static unsafe Vector256<float> MaskLoad(float* address, Vector256<uint> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_maskload_pd (double const * mem_addr, __m256i mask)
+ /// </summary>
+ public static unsafe Vector256<double> MaskLoad(double* address, Vector256<ulong> mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm_maskstore_ps (float * mem_addr, __m128i mask, __m128 a)
+ /// </summary>
+ public static unsafe void MaskStore(float* address, Vector128<float> mask, Vector128<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_maskstore_pd (double * mem_addr, __m128i mask, __m128d a)
+ /// </summary>
+ public static unsafe void MaskStore(double* address, Vector128<double> mask, Vector128<ulong> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm256_maskstore_ps (float * mem_addr, __m256i mask, __m256 a)
+ /// </summary>
+ public static unsafe void MaskStore(float* address, Vector256<float> mask, Vector256<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_maskstore_pd (double * mem_addr, __m256i mask, __m256d a)
+ /// </summary>
+ public static unsafe void MaskStore(double* address, Vector256<double> mask, Vector256<ulong> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_max_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> Max(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_max_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> Max(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_min_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> Min(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_min_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> Min(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm256_movemask_ps (__m256 a)
+ /// </summary>
+ public static int MoveMask(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// int _mm256_movemask_pd (__m256d a)
+ /// </summary>
+ public static int MoveMask(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_mul_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> Multiply(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_mul_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> Multiply(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_or_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> Or(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_or_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> Or(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_permute_ps (__m128 a, int imm8)
+ /// </summary>
+ public static Vector128<float> Permute(Vector128<float> value, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_permute_pd (__m128d a, int imm8)
+ /// </summary>
+ public static Vector128<double> Permute(Vector128<double> value, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_permute_ps (__m256 a, int imm8)
+ /// </summary>
+ public static Vector256<float> Permute(Vector256<float> value, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_permute_pd (__m256d a, int imm8)
+ /// </summary>
+ public static Vector256<double> Permute(Vector256<double> value, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8)
+ /// </summary>
+ public static Vector256<float> Permute2x128(Vector256<float> left, Vector256<float> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8)
+ /// </summary>
+ public static Vector256<double> Permute2x128(Vector256<double> left, Vector256<double> right, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_permutevar_ps (__m128 a, __m128i b)
+ /// </summary>
+ public static Vector128<float> PermuteVar(Vector128<float> left, Vector128<float> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_permutevar_pd (__m128d a, __m128i b)
+ /// </summary>
+ public static Vector128<double> PermuteVar(Vector128<double> left, Vector128<double> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_permutevar_ps (__m256 a, __m256i b)
+ /// </summary>
+ public static Vector256<float> PermuteVar(Vector256<float> left, Vector256<float> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_permutevar_pd (__m256d a, __m256i b)
+ /// </summary>
+ public static Vector256<double> PermuteVar(Vector256<double> left, Vector256<double> mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_rcp_ps (__m256 a)
+ /// </summary>
+ public static Vector256<float> Reciprocal(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_rsqrt_ps (__m256 a)
+ /// </summary>
+ public static Vector256<float> ReciprocalSqrt(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_round_ps (__m256 a, int rounding)
+ /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector256<float> RoundToNearestInteger(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector256<float> RoundToNegativeInfinity(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector256<float> RoundToPositiveInfinity(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector256<float> RoundToZero(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_CUR_DIRECTION
+ /// </summary>
+ public static Vector256<float> RoundCurrentDirection(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256d _mm256_round_pd (__m256d a, int rounding)
+ /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector256<double> RoundToNearestInteger(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector256<double> RoundToNegativeInfinity(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector256<double> RoundToPositiveInfinity(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector256<double> RoundToZero(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_CUR_DIRECTION
+ /// </summary>
+ public static Vector256<double> RoundCurrentDirection(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_set_epi8 (char e31, char e30, char e29, char e28, char e27, char e26, char e25, char e24, char e23, char e22, char e21, char e20, char e19, char e18, char e17, char e16, char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0)
+ /// </summary>
+ public static Vector256<sbyte> Set(sbyte e31, sbyte e30, sbyte e29, sbyte e28, sbyte e27, sbyte e26, sbyte e25, sbyte e24, sbyte e23, sbyte e22, sbyte e21, sbyte e20, sbyte e19, sbyte e18, sbyte e17, sbyte e16, sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_set_epi8 (char e31, char e30, char e29, char e28, char e27, char e26, char e25, char e24, char e23, char e22, char e21, char e20, char e19, char e18, char e17, char e16, char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0)
+ /// </summary>
+ public static Vector256<byte> Set(byte e31, byte e30, byte e29, byte e28, byte e27, byte e26, byte e25, byte e24, byte e23, byte e22, byte e21, byte e20, byte e19, byte e18, byte e17, byte e16, byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_set_epi16 (short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0)
+ /// </summary>
+ public static Vector256<short> Set(short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_set_epi16 (short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0)
+ /// </summary>
+ public static Vector256<ushort> Set(ushort e15, ushort e14, ushort e13, ushort e12, ushort e11, ushort e10, ushort e9, ushort e8, ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_set_epi32 (int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0)
+ /// </summary>
+ public static Vector256<int> Set(int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_set_epi32 (int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0)
+ /// </summary>
+ public static Vector256<uint> Set(uint e7, uint e6, uint e5, uint e4, uint e3, uint e2, uint e1, uint e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_set_epi64x (__int64 e3, __int64 e2, __int64 e1, __int64 e0)
+ /// </summary>
+ public static Vector256<long> Set(long e3, long e2, long e1, long e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_set_epi64x (__int64 e3, __int64 e2, __int64 e1, __int64 e0)
+ /// </summary>
+ public static Vector256<ulong> Set(ulong e3, ulong e2, ulong e1, ulong e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_set_ps (float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0)
+ /// </summary>
+ public static Vector256<float> Set(float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_set_pd (double e3, double e2, double e1, double e0)
+ /// </summary>
+ public static Vector256<double> Set(double e3, double e2, double e1, double e0) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_set1_epi8 (char a)
+ /// __m256i _mm256_set1_epi16 (short a)
+ /// __m256i _mm256_set1_epi32 (int a)
+ /// __m256i _mm256_set1_epi64x (long long a)
+ /// __m256 _mm256_set1_ps (float a)
+ /// __m256d _mm256_set1_pd (double a)
+ /// </summary>
+ public static Vector256<T> Set1<T>(T value) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_set_m128 (__m128 hi, __m128 lo)
+ /// __m256d _mm256_set_m128d (__m128d hi, __m128d lo)
+ /// __m256i _mm256_set_m128i (__m128i hi, __m128i lo)
+ /// </summary>
+ public static Vector256<T> SetHiLo<T>(Vector128<T> hi, Vector128<T> lo) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_setzero_si256 (void)
+ /// __m256 _mm256_setzero_ps (void)
+ /// __m256d _mm256_setzero_pd (void)
+ /// </summary>
+ public static Vector256<T> SetZero<T>() where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8)
+ /// </summary>
+ public static Vector256<float> Shuffle(Vector256<float> value, Vector256<float> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int imm8)
+ /// </summary>
+ public static Vector256<double> Shuffle(Vector256<double> value, Vector256<double> right, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_sqrt_ps (__m256 a)
+ /// </summary>
+ public static Vector256<float> Sqrt(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_sqrt_pd (__m256d a)
+ /// </summary>
+ public static Vector256<double> Sqrt(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_castpd_ps (__m256d a)
+ /// __m256i _mm256_castpd_si256 (__m256d a)
+ /// __m256d _mm256_castps_pd (__m256 a)
+ /// __m256i _mm256_castps_si256 (__m256 a)
+ /// __m256d _mm256_castsi256_pd (__m256i a)
+ /// __m256 _mm256_castsi256_ps (__m256i a)
+ /// </summary>
+ public static Vector256<U> StaticCast<T, U>(Vector256<T> value) where T : struct where U : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAligned(sbyte* address, Vector256<sbyte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAligned(byte* address, Vector256<byte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAligned(short* address, Vector256<short> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAligned(ushort* address, Vector256<ushort> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAligned(int* address, Vector256<int> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAligned(uint* address, Vector256<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAligned(long* address, Vector256<long> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAligned(ulong* address, Vector256<ulong> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_store_ps (float * mem_addr, __m256 a)
+ /// </summary>
+ public static unsafe void StoreAligned(float* address, Vector256<float> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_store_pd (double * mem_addr, __m256d a)
+ /// </summary>
+ public static unsafe void StoreAligned(double* address, Vector256<double> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector256<sbyte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(byte* address, Vector256<byte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(short* address, Vector256<short> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector256<ushort> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(int* address, Vector256<int> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(uint* address, Vector256<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(long* address, Vector256<long> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector256<ulong> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_stream_ps (float * mem_addr, __m256 a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(float* address, Vector256<float> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_stream_pd (double * mem_addr, __m256d a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(double* address, Vector256<double> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void Store(sbyte* address, Vector256<sbyte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void Store(byte* address, Vector256<byte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void Store(short* address, Vector256<short> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void Store(ushort* address, Vector256<ushort> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void Store(int* address, Vector256<int> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void Store(uint* address, Vector256<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void Store(long* address, Vector256<long> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
+ /// </summary>
+ public static unsafe void Store(ulong* address, Vector256<ulong> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_storeu_ps (float * mem_addr, __m256 a)
+ /// </summary>
+ public static unsafe void Store(float* address, Vector256<float> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_storeu_pd (double * mem_addr, __m256d a)
+ /// </summary>
+ public static unsafe void Store(double* address, Vector256<double> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_sub_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> Subtract(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_sub_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> Subtract(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_testc_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static bool TestC(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// int _mm_testc_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static bool TestC(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm256_testc_si256 (__m256i a, __m256i b)
+ /// int _mm256_testc_ps (__m256 a, __m256 b)
+ /// int _mm256_testc_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static bool TestC<T>(Vector256<T> left, Vector256<T> right) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_testnzc_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static bool TestNotZAndNotC(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// int _mm_testnzc_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static bool TestNotZAndNotC(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm256_testnzc_si256 (__m256i a, __m256i b)
+ /// int _mm256_testnzc_ps (__m256 a, __m256 b)
+ /// int _mm256_testnzc_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static bool TestNotZAndNotC<T>(Vector256<T> left, Vector256<T> right) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_testz_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static bool TestZ(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// int _mm_testz_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static bool TestZ(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm256_testz_si256 (__m256i a, __m256i b)
+ /// int _mm256_testz_ps (__m256 a, __m256 b)
+ /// int _mm256_testz_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static bool TestZ<T>(Vector256<T> left, Vector256<T> right) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_unpackhi_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> UnpackHigh(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_unpackhi_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> UnpackHigh(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_unpacklo_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> UnpackLow(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_unpacklo_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> UnpackLow(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256 _mm256_xor_ps (__m256 a, __m256 b)
+ /// </summary>
+ public static Vector256<float> Xor(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_xor_pd (__m256d a, __m256d b)
+ /// </summary>
+ public static Vector256<double> Xor(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm256_zeroall (void)
+ /// </summary>
+ public static void ZeroAll() { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_zeroupper (void)
+ /// </summary>
+ public static void ZeroUpper() { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256d _mm256_zextpd128_pd256 (__m128d a)
+ /// __m256 _mm256_zextps128_ps256 (__m128 a)
+ /// __m256i _mm256_zextsi128_si256 (__m128i a)
+ /// </summary>
+ public static Vector256<T> ZeroExtendToVector256<T>(Vector128<T> value) where T : struct { throw new PlatformNotSupportedException(); }
+ }
+}
[CLSCompliant(false)]
public static class Avx
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// __m256 _mm256_add_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> Add(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> Add(Vector256<float> left, Vector256<float> right) => Add(left, right);
/// <summary>
/// __m256d _mm256_add_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> Add(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> Add(Vector256<double> left, Vector256<double> right) => Add(left, right);
/// <summary>
/// __m256 _mm256_addsub_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> AddSubtract(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> AddSubtract(Vector256<float> left, Vector256<float> right) => AddSubtract(left, right);
/// <summary>
/// __m256d _mm256_addsub_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> AddSubtract(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> AddSubtract(Vector256<double> left, Vector256<double> right) => AddSubtract(left, right);
/// <summary>
/// __m256 _mm256_and_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> And(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> And(Vector256<float> left, Vector256<float> right) => And(left, right);
/// <summary>
/// __m256d _mm256_and_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> And(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> And(Vector256<double> left, Vector256<double> right) => And(left, right);
/// <summary>
/// __m256 _mm256_andnot_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> AndNot(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> AndNot(Vector256<float> left, Vector256<float> right) => AndNot(left, right);
/// <summary>
/// __m256d _mm256_andnot_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> AndNot(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> AndNot(Vector256<double> left, Vector256<double> right) => AndNot(left, right);
/// <summary>
/// __m256 _mm256_blend_ps (__m256 a, __m256 b, const int imm8)
/// </summary>
- public static Vector256<float> Blend(Vector256<float> left, Vector256<float> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<float> Blend(Vector256<float> left, Vector256<float> right, byte control) => Blend(left, right, control);
/// <summary>
/// __m256d _mm256_blend_pd (__m256d a, __m256d b, const int imm8)
/// </summary>
- public static Vector256<double> Blend(Vector256<double> left, Vector256<double> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<double> Blend(Vector256<double> left, Vector256<double> right, byte control) => Blend(left, right, control);
/// <summary>
/// __m256 _mm256_blendv_ps (__m256 a, __m256 b, __m256 mask)
/// </summary>
- public static Vector256<float> BlendVariable(Vector256<float> left, Vector256<float> right, Vector256<float> mask) { throw new NotImplementedException(); }
+ public static Vector256<float> BlendVariable(Vector256<float> left, Vector256<float> right, Vector256<float> mask) => BlendVariable(left, right, mask);
/// <summary>
/// __m256d _mm256_blendv_pd (__m256d a, __m256d b, __m256d mask)
/// </summary>
- public static Vector256<double> BlendVariable(Vector256<double> left, Vector256<double> right, Vector256<double> mask) { throw new NotImplementedException(); }
+ public static Vector256<double> BlendVariable(Vector256<double> left, Vector256<double> right, Vector256<double> mask) => BlendVariable(left, right, mask);
/// <summary>
/// __m128 _mm_broadcast_ss (float const * mem_addr)
/// </summary>
- public static Vector128<float> BroadcastElementToVector128(ref float source) { throw new NotImplementedException(); }
+ public static Vector128<float> BroadcastElementToVector128(ref float source) => BroadcastElementToVector128(ref source);
/// <summary>
/// __m256 _mm256_broadcast_ss (float const * mem_addr)
/// </summary>
- public static Vector256<float> BroadcastElementToVector256(ref float source) { throw new NotImplementedException(); }
+ public static Vector256<float> BroadcastElementToVector256(ref float source) => BroadcastElementToVector256(ref source);
/// <summary>
/// __m256d _mm256_broadcast_sd (double const * mem_addr)
/// </summary>
- public static Vector256<double> BroadcastElementToVector256(ref double source) { throw new NotImplementedException(); }
+ public static Vector256<double> BroadcastElementToVector256(ref double source) => BroadcastElementToVector256(ref source);
/// <summary>
/// __m256 _mm256_broadcast_ps (__m128 const * mem_addr)
/// </summary>
- public static unsafe Vector256<float> BroadcastVector128ToVector256(float* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<float> BroadcastVector128ToVector256(float* address) => BroadcastVector128ToVector256(address);
/// <summary>
/// __m256d _mm256_broadcast_pd (__m128d const * mem_addr)
/// </summary>
- public static unsafe Vector256<double> BroadcastVector128ToVector256(double* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<double> BroadcastVector128ToVector256(double* address) => BroadcastVector128ToVector256(address);
/// <summary>
/// __m256 _mm256_ceil_ps (__m256 a)
/// </summary>
- public static Vector256<float> Ceiling(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<float> Ceiling(Vector256<float> value) => Ceiling(value);
/// <summary>
/// __m256d _mm256_ceil_pd (__m256d a)
/// </summary>
- public static Vector256<double> Ceiling(Vector256<double> value) { throw new NotImplementedException(); }
+ public static Vector256<double> Ceiling(Vector256<double> value) => Ceiling(value);
/// <summary>
/// __m128 _mm_cmp_ps (__m128 a, __m128 b, const int imm8)
/// </summary>
- public static Vector128<float> Compare(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<float> Compare(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode) => Compare(left, right, mode);
/// <summary>
/// __m128d _mm_cmp_pd (__m128d a, __m128d b, const int imm8)
/// </summary>
- public static Vector128<double> Compare(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<double> Compare(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode) => Compare(left, right, mode);
/// <summary>
/// __m256 _mm256_cmp_ps (__m256 a, __m256 b, const int imm8)
/// </summary>
- public static Vector256<float> Compare(Vector256<float> left, Vector256<float> right, FloatComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector256<float> Compare(Vector256<float> left, Vector256<float> right, FloatComparisonMode mode) => Compare(left, right, mode);
/// <summary>
/// __m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8)
/// </summary>
- public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, FloatComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, FloatComparisonMode mode) => Compare(left, right, mode);
/// <summary>
/// __m128i _mm256_cvtpd_epi32 (__m256d a)
/// </summary>
- public static Vector128<int> ConvertToVector128Int(Vector256<double> value) { throw new NotImplementedException(); }
+ public static Vector128<int> ConvertToVector128Int(Vector256<double> value) => ConvertToVector128Int(value);
/// <summary>
/// __m128 _mm256_cvtpd_ps (__m256d a)
/// </summary>
- public static Vector128<float> ConvertToVector128Float(Vector256<double> value) { throw new NotImplementedException(); }
+ public static Vector128<float> ConvertToVector128Float(Vector256<double> value) => ConvertToVector128Float(value);
/// <summary>
/// __m256i _mm256_cvtps_epi32 (__m256 a)
/// </summary>
- public static Vector256<int> ConvertToVector256Int(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<int> ConvertToVector256Int(Vector256<float> value) => ConvertToVector256Int(value);
/// <summary>
/// __m256 _mm256_cvtepi32_ps (__m256i a)
/// </summary>
- public static Vector256<float> ConvertToVector256Float(Vector256<int> value) { throw new NotImplementedException(); }
+ public static Vector256<float> ConvertToVector256Float(Vector256<int> value) => ConvertToVector256Float(value);
/// <summary>
/// __m256d _mm256_cvtps_pd (__m128 a)
/// </summary>
- public static Vector256<double> ConvertToVector256Double(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<double> ConvertToVector256Double(Vector256<float> value) => ConvertToVector256Double(value);
/// <summary>
/// __m256d _mm256_cvtepi32_pd (__m128i a)
/// </summary>
- public static Vector256<double> ConvertToVector256Double(Vector256<int> value) { throw new NotImplementedException(); }
+ public static Vector256<double> ConvertToVector256Double(Vector256<int> value) => ConvertToVector256Double(value);
/// <summary>
/// __m128i _mm256_cvttpd_epi32 (__m256d a)
/// </summary>
- public static Vector128<int> ConvertToVector128IntWithTruncation(Vector256<double> value) { throw new NotImplementedException(); }
+ public static Vector128<int> ConvertToVector128IntWithTruncation(Vector256<double> value) => ConvertToVector128IntWithTruncation(value);
/// <summary>
/// __m256i _mm256_cvttps_epi32 (__m256 a)
/// </summary>
- public static Vector256<int> ConvertToVector256IntWithTruncation(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<int> ConvertToVector256IntWithTruncation(Vector256<float> value) => ConvertToVector256IntWithTruncation(value);
/// <summary>
/// __m256 _mm256_div_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> Divide(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> Divide(Vector256<float> left, Vector256<float> right) => Divide(left, right);
/// <summary>
/// __m256d _mm256_div_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> Divide(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> Divide(Vector256<double> left, Vector256<double> right) => Divide(left, right);
/// <summary>
/// __m256 _mm256_dp_ps (__m256 a, __m256 b, const int imm8)
/// </summary>
- public static Vector256<float> DotProduct(Vector256<float> left, Vector256<float> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<float> DotProduct(Vector256<float> left, Vector256<float> right, byte control) => DotProduct(left, right, control);
/// <summary>
/// __m256 _mm256_moveldup_ps (__m256 a)
/// </summary>
- public static Vector256<float> DuplicateEvenIndexed(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<float> DuplicateEvenIndexed(Vector256<float> value) => DuplicateEvenIndexed(value);
/// <summary>
/// __m256d _mm256_movedup_pd (__m256d a)
/// </summary>
- public static Vector256<double> DuplicateEvenIndexed(Vector256<double> value) { throw new NotImplementedException(); }
+ public static Vector256<double> DuplicateEvenIndexed(Vector256<double> value) => DuplicateEvenIndexed(value);
/// <summary>
/// __m256 _mm256_movehdup_ps (__m256 a)
/// </summary>
- public static Vector256<float> DuplicateOddIndexed(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<float> DuplicateOddIndexed(Vector256<float> value) => DuplicateOddIndexed(value);
/// <summary>
/// __int8 _mm256_extract_epi8 (__m256i a, const int index)
/// </summary>
- public static sbyte ExtractSbyte<T>(Vector256<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static sbyte ExtractSbyte<T>(Vector256<T> value, byte index) where T : struct => ExtractSbyte<T>(value, index);
/// <summary>
/// __int8 _mm256_extract_epi8 (__m256i a, const int index)
/// </summary>
- public static byte ExtractByte<T>(Vector256<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static byte ExtractByte<T>(Vector256<T> value, byte index) where T : struct => ExtractByte<T>(value, index);
/// <summary>
/// __int16 _mm256_extract_epi16 (__m256i a, const int index)
/// </summary>
- public static short ExtractShort<T>(Vector256<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static short ExtractShort<T>(Vector256<T> value, byte index) where T : struct => ExtractShort<T>(value, index);
/// <summary>
/// __int16 _mm256_extract_epi16 (__m256i a, const int index)
/// </summary>
- public static ushort ExtractUshort<T>(Vector256<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static ushort ExtractUshort<T>(Vector256<T> value, byte index) where T : struct => ExtractUshort<T>(value, index);
/// <summary>
/// __int32 _mm256_extract_epi32 (__m256i a, const int index)
/// </summary>
- public static int ExtractInt<T>(Vector256<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static int ExtractInt<T>(Vector256<T> value, byte index) where T : struct => ExtractInt<T>(value, index);
/// <summary>
/// __int32 _mm256_extract_epi32 (__m256i a, const int index)
/// </summary>
- public static uint ExtractUint<T>(Vector256<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static uint ExtractUint<T>(Vector256<T> value, byte index) where T : struct => ExtractUint<T>(value, index);
/// <summary>
/// __int64 _mm256_extract_epi64 (__m256i a, const int index)
/// </summary>
- public static long ExtractLong<T>(Vector256<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static long ExtractLong<T>(Vector256<T> value, byte index) where T : struct => ExtractLong<T>(value, index);
/// <summary>
/// __int64 _mm256_extract_epi64 (__m256i a, const int index)
/// </summary>
- public static ulong ExtractUlong<T>(Vector256<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static ulong ExtractUlong<T>(Vector256<T> value, byte index) where T : struct => ExtractUlong<T>(value, index);
/// <summary>
/// __m128 _mm256_extractf128_ps (__m256 a, const int imm8)
/// __m128d _mm256_extractf128_pd (__m256d a, const int imm8)
/// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
/// </summary>
- public static Vector128<T> ExtractVector128<T>(Vector256<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> ExtractVector128<T>(Vector256<T> value, byte index) where T : struct => ExtractVector128<T>(value, index);
/// <summary>
/// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(byte* address, Vector256<byte> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(byte* address, Vector256<byte> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(sbyte* address, Vector256<sbyte> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(sbyte* address, Vector256<sbyte> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(short* address, Vector256<short> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(short* address, Vector256<short> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(ushort* address, Vector256<ushort> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(ushort* address, Vector256<ushort> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(int* address, Vector256<int> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(int* address, Vector256<int> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(uint* address, Vector256<uint> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(uint* address, Vector256<uint> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(long* address, Vector256<long> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(long* address, Vector256<long> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(ulong* address, Vector256<ulong> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(ulong* address, Vector256<ulong> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128 _mm256_extractf128_ps (__m256 a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(float* address, Vector256<float> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(float* address, Vector256<float> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128d _mm256_extractf128_pd (__m256d a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(double* address, Vector256<double> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(double* address, Vector256<double> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m256d _mm256_castpd128_pd256 (__m128d a)
/// __m256 _mm256_castps128_ps256 (__m128 a)
/// __m256i _mm256_castsi128_si256 (__m128i a)
/// </summary>
- public static Vector256<T> ExtendToVector256<T>(Vector128<T> value) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> ExtendToVector256<T>(Vector128<T> value) where T : struct => ExtendToVector256<T>(value);
/// <summary>
/// __m256 _mm256_floor_ps (__m256 a)
/// </summary>
- public static Vector256<float> Floor(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<float> Floor(Vector256<float> value) => Floor(value);
/// <summary>
/// __m256d _mm256_floor_pd (__m256d a)
/// </summary>
- public static Vector256<double> Floor(Vector256<double> value) { throw new NotImplementedException(); }
+ public static Vector256<double> Floor(Vector256<double> value) => Floor(value);
/// <summary>
/// __m128d _mm256_castpd256_pd128 (__m256d a)
/// __m128 _mm256_castps256_ps128 (__m256 a)
/// __m128i _mm256_castsi256_si128 (__m256i a)
/// </summary>
- public static Vector128<T> GetLowerHalf<T>(Vector256<T> value) where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> GetLowerHalf<T>(Vector256<T> value) where T : struct => GetLowerHalf<T>(value);
/// <summary>
/// __m256 _mm256_hadd_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> HorizontalAdd(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> HorizontalAdd(Vector256<float> left, Vector256<float> right) => HorizontalAdd(left, right);
/// <summary>
/// __m256d _mm256_hadd_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> HorizontalAdd(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> HorizontalAdd(Vector256<double> left, Vector256<double> right) => HorizontalAdd(left, right);
/// <summary>
/// __m256 _mm256_hsub_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> HorizontalSubtract(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> HorizontalSubtract(Vector256<float> left, Vector256<float> right) => HorizontalSubtract(left, right);
/// <summary>
/// __m256d _mm256_hsub_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> HorizontalSubtract(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> HorizontalSubtract(Vector256<double> left, Vector256<double> right) => HorizontalSubtract(left, right);
/// <summary>
/// __m256i _mm256_insert_epi8 (__m256i a, __int8 i, const int index)
/// </summary>
- public static Vector256<T> InsertSbyte<T>(Vector256<T> value, sbyte data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> InsertSbyte<T>(Vector256<T> value, sbyte data, byte index) where T : struct => InsertSbyte<T>(value, data, index);
/// <summary>
/// __m256i _mm256_insert_epi8 (__m256i a, __int8 i, const int index)
/// </summary>
- public static Vector256<T> InsertByte<T>(Vector256<T> value, byte data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> InsertByte<T>(Vector256<T> value, byte data, byte index) where T : struct => InsertByte<T>(value, data, index);
/// <summary>
/// __m256i _mm256_insert_epi16 (__m256i a, __int16 i, const int index)
/// </summary>
- public static Vector256<T> InsertShort<T>(Vector256<T> value, short data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> InsertShort<T>(Vector256<T> value, short data, byte index) where T : struct => InsertShort<T>(value, data, index);
/// <summary>
/// __m256i _mm256_insert_epi16 (__m256i a, __int16 i, const int index)
/// </summary>
- public static Vector256<T> InsertUshort<T>(Vector256<T> value, ushort data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> InsertUshort<T>(Vector256<T> value, ushort data, byte index) where T : struct => InsertUshort<T>(value, data, index);
/// <summary>
/// __m256i _mm256_insert_epi32 (__m256i a, __int32 i, const int index)
/// </summary>
- public static Vector256<T> InsertInt<T>(Vector256<T> value, int data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> InsertInt<T>(Vector256<T> value, int data, byte index) where T : struct => InsertInt<T>(value, data, index);
/// <summary>
/// __m256i _mm256_insert_epi32 (__m256i a, __int32 i, const int index)
/// </summary>
- public static Vector256<T> InsertUint<T>(Vector256<T> value, uint data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> InsertUint<T>(Vector256<T> value, uint data, byte index) where T : struct => InsertUint<T>(value, data, index);
/// <summary>
/// __m256i _mm256_insert_epi64 (__m256i a, __int64 i, const int index)
/// </summary>
- public static Vector256<T> InsertLong<T>(Vector256<T> value, long data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> InsertLong<T>(Vector256<T> value, long data, byte index) where T : struct => InsertLong<T>(value, data, index);
/// <summary>
/// __m256i _mm256_insert_epi64 (__m256i a, __int64 i, const int index)
/// </summary>
- public static Vector256<T> InsertUlong<T>(Vector256<T> value, ulong data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> InsertUlong<T>(Vector256<T> value, ulong data, byte index) where T : struct => InsertUlong<T>(value, data, index);
/// <summary>
/// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8)
/// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8)
/// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
/// </summary>
- public static Vector256<T> Insert<T>(Vector256<T> value, Vector128<T> data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> Insert<T>(Vector256<T> value, Vector128<T> data, byte index) where T : struct => Insert<T>(value, data, index);
/// <summary>
/// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
/// </summary>
- public static unsafe Vector256<sbyte> Insert(Vector256<sbyte> value, sbyte* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<sbyte> Insert(Vector256<sbyte> value, sbyte* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
/// </summary>
- public static unsafe Vector256<byte> Insert(Vector256<byte> value, byte* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<byte> Insert(Vector256<byte> value, byte* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
/// </summary>
- public static unsafe Vector256<short> Insert(Vector256<short> value, short* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<short> Insert(Vector256<short> value, short* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
/// </summary>
- public static unsafe Vector256<ushort> Insert(Vector256<ushort> value, ushort* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ushort> Insert(Vector256<ushort> value, ushort* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
/// </summary>
- public static unsafe Vector256<int> Insert(Vector256<int> value, int* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<int> Insert(Vector256<int> value, int* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
/// </summary>
- public static unsafe Vector256<uint> Insert(Vector256<uint> value, uint* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<uint> Insert(Vector256<uint> value, uint* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
/// </summary>
- public static unsafe Vector256<long> Insert(Vector256<long> value, long* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<long> Insert(Vector256<long> value, long* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
/// </summary>
- public static unsafe Vector256<ulong> Insert(Vector256<ulong> value, ulong* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ulong> Insert(Vector256<ulong> value, ulong* address) => Insert(value, address);
/// <summary>
/// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8)
/// </summary>
- public static unsafe Vector256<float> Insert(Vector256<float> value, float* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<float> Insert(Vector256<float> value, float* address) => Insert(value, address);
/// <summary>
/// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8)
/// </summary>
- public static unsafe Vector256<double> Insert(Vector256<double> value, double* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<double> Insert(Vector256<double> value, double* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<sbyte> Load(sbyte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<sbyte> Load(sbyte* address) => Load(address);
/// <summary>
/// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<byte> Load(byte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<byte> Load(byte* address) => Load(address);
/// <summary>
/// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<short> Load(short* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<short> Load(short* address) => Load(address);
/// <summary>
/// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<ushort> Load(ushort* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ushort> Load(ushort* address) => Load(address);
/// <summary>
/// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<int> Load(int* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<int> Load(int* address) => Load(address);
/// <summary>
/// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<uint> Load(uint* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<uint> Load(uint* address) => Load(address);
/// <summary>
/// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<long> Load(long* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<long> Load(long* address) => Load(address);
/// <summary>
/// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<ulong> Load(ulong* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ulong> Load(ulong* address) => Load(address);
/// <summary>
/// __m256 _mm256_loadu_ps (float const * mem_addr)
/// </summary>
- public static unsafe Vector256<float> Load(float* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<float> Load(float* address) => Load(address);
/// <summary>
/// __m256d _mm256_loadu_pd (double const * mem_addr)
/// </summary>
- public static unsafe Vector256<double> Load(double* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<double> Load(double* address) => Load(address);
/// <summary>
/// __m256i _mm256_load_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<sbyte> LoadAligned(sbyte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<sbyte> LoadAligned(sbyte* address) => LoadAligned(address);
/// <summary>
/// __m256i _mm256_load_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<byte> LoadAligned(byte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<byte> LoadAligned(byte* address) => LoadAligned(address);
/// <summary>
/// __m256i _mm256_load_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<short> LoadAligned(short* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<short> LoadAligned(short* address) => LoadAligned(address);
/// <summary>
/// __m256i _mm256_load_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<ushort> LoadAligned(ushort* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ushort> LoadAligned(ushort* address) => LoadAligned(address);
/// <summary>
/// __m256i _mm256_load_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<int> LoadAligned(int* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<int> LoadAligned(int* address) => LoadAligned(address);
/// <summary>
/// __m256i _mm256_load_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<uint> LoadAligned(uint* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<uint> LoadAligned(uint* address) => LoadAligned(address);
/// <summary>
/// __m256i _mm256_load_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<long> LoadAligned(long* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<long> LoadAligned(long* address) => LoadAligned(address);
/// <summary>
/// __m256i _mm256_load_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<ulong> LoadAligned(ulong* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ulong> LoadAligned(ulong* address) => LoadAligned(address);
/// <summary>
/// __m256 _mm256_load_ps (float const * mem_addr)
/// </summary>
- public static unsafe Vector256<float> LoadAligned(float* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<float> LoadAligned(float* address) => LoadAligned(address);
/// <summary>
/// __m256d _mm256_load_pd (double const * mem_addr)
/// </summary>
- public static unsafe Vector256<double> LoadAligned(double* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<double> LoadAligned(double* address) => LoadAligned(address);
/// <summary>
/// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<sbyte> LoadDqu(sbyte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<sbyte> LoadDqu(sbyte* address) => LoadDqu(address);
/// <summary>
/// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<byte> LoadDqu(byte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<byte> LoadDqu(byte* address) => LoadDqu(address);
/// <summary>
/// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<short> LoadDqu(short* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<short> LoadDqu(short* address) => LoadDqu(address);
/// <summary>
/// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<ushort> LoadDqu(ushort* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ushort> LoadDqu(ushort* address) => LoadDqu(address);
/// <summary>
/// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<int> LoadDqu(int* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<int> LoadDqu(int* address) => LoadDqu(address);
/// <summary>
/// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<uint> LoadDqu(uint* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<uint> LoadDqu(uint* address) => LoadDqu(address);
/// <summary>
/// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<long> LoadDqu(long* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<long> LoadDqu(long* address) => LoadDqu(address);
/// <summary>
/// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
/// </summary>
- public static unsafe Vector256<ulong> LoadDqu(ulong* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ulong> LoadDqu(ulong* address) => LoadDqu(address);
/// <summary>
/// __m128d _mm_maskload_pd (double const * mem_addr, __m128i mask)
/// </summary>
- public static unsafe Vector128<float> MaskLoad(float* address, Vector128<uint> mask) { throw new NotImplementedException(); }
+ public static unsafe Vector128<float> MaskLoad(float* address, Vector128<uint> mask) => MaskLoad(address, mask);
/// <summary>
/// __m128d _mm_maskload_pd (double const * mem_addr, __m128i mask)
/// </summary>
- public static unsafe Vector128<double> MaskLoad(double* address, Vector128<ulong> mask) { throw new NotImplementedException(); }
+ public static unsafe Vector128<double> MaskLoad(double* address, Vector128<ulong> mask) => MaskLoad(address, mask);
/// <summary>
/// __m256 _mm256_maskload_ps (float const * mem_addr, __m256i mask)
/// </summary>
- public static unsafe Vector256<float> MaskLoad(float* address, Vector256<uint> mask) { throw new NotImplementedException(); }
+ public static unsafe Vector256<float> MaskLoad(float* address, Vector256<uint> mask) => MaskLoad(address, mask);
/// <summary>
/// __m256d _mm256_maskload_pd (double const * mem_addr, __m256i mask)
/// </summary>
- public static unsafe Vector256<double> MaskLoad(double* address, Vector256<ulong> mask) { throw new NotImplementedException(); }
+ public static unsafe Vector256<double> MaskLoad(double* address, Vector256<ulong> mask) => MaskLoad(address, mask);
/// <summary>
/// void _mm_maskstore_ps (float * mem_addr, __m128i mask, __m128 a)
/// </summary>
- public static unsafe void MaskStore(float* address, Vector128<float> mask, Vector128<uint> source) { throw new NotImplementedException(); }
+ public static unsafe void MaskStore(float* address, Vector128<float> mask, Vector128<uint> source) => MaskStore(address, mask, source);
/// <summary>
/// void _mm_maskstore_pd (double * mem_addr, __m128i mask, __m128d a)
/// </summary>
- public static unsafe void MaskStore(double* address, Vector128<double> mask, Vector128<ulong> source) { throw new NotImplementedException(); }
+ public static unsafe void MaskStore(double* address, Vector128<double> mask, Vector128<ulong> source) => MaskStore(address, mask, source);
/// <summary>
/// void _mm256_maskstore_ps (float * mem_addr, __m256i mask, __m256 a)
/// </summary>
- public static unsafe void MaskStore(float* address, Vector256<float> mask, Vector256<uint> source) { throw new NotImplementedException(); }
+ public static unsafe void MaskStore(float* address, Vector256<float> mask, Vector256<uint> source) => MaskStore(address, mask, source);
/// <summary>
/// void _mm256_maskstore_pd (double * mem_addr, __m256i mask, __m256d a)
/// </summary>
- public static unsafe void MaskStore(double* address, Vector256<double> mask, Vector256<ulong> source) { throw new NotImplementedException(); }
+ public static unsafe void MaskStore(double* address, Vector256<double> mask, Vector256<ulong> source) => MaskStore(address, mask, source);
/// <summary>
/// __m256 _mm256_max_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> Max(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> Max(Vector256<float> left, Vector256<float> right) => Max(left, right);
/// <summary>
/// __m256d _mm256_max_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> Max(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> Max(Vector256<double> left, Vector256<double> right) => Max(left, right);
/// <summary>
/// __m256 _mm256_min_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> Min(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> Min(Vector256<float> left, Vector256<float> right) => Min(left, right);
/// <summary>
/// __m256d _mm256_min_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> Min(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> Min(Vector256<double> left, Vector256<double> right) => Min(left, right);
/// <summary>
/// int _mm256_movemask_ps (__m256 a)
/// </summary>
- public static int MoveMask(Vector256<float> value) { throw new NotImplementedException(); }
+ public static int MoveMask(Vector256<float> value) => MoveMask(value);
/// <summary>
/// int _mm256_movemask_pd (__m256d a)
/// </summary>
- public static int MoveMask(Vector256<double> value) { throw new NotImplementedException(); }
+ public static int MoveMask(Vector256<double> value) => MoveMask(value);
/// <summary>
/// __m256 _mm256_mul_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> Multiply(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> Multiply(Vector256<float> left, Vector256<float> right) => Multiply(left, right);
/// <summary>
/// __m256d _mm256_mul_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> Multiply(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> Multiply(Vector256<double> left, Vector256<double> right) => Multiply(left, right);
/// <summary>
/// __m256 _mm256_or_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> Or(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> Or(Vector256<float> left, Vector256<float> right) => Or(left, right);
/// <summary>
/// __m256d _mm256_or_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> Or(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> Or(Vector256<double> left, Vector256<double> right) => Or(left, right);
/// <summary>
/// __m128 _mm_permute_ps (__m128 a, int imm8)
/// </summary>
- public static Vector128<float> Permute(Vector128<float> value, byte control) { throw new NotImplementedException(); }
+ public static Vector128<float> Permute(Vector128<float> value, byte control) => Permute(value, control);
/// <summary>
/// __m128d _mm_permute_pd (__m128d a, int imm8)
/// </summary>
- public static Vector128<double> Permute(Vector128<double> value, byte control) { throw new NotImplementedException(); }
+ public static Vector128<double> Permute(Vector128<double> value, byte control) => Permute(value, control);
/// <summary>
/// __m256 _mm256_permute_ps (__m256 a, int imm8)
/// </summary>
- public static Vector256<float> Permute(Vector256<float> value, byte control) { throw new NotImplementedException(); }
+ public static Vector256<float> Permute(Vector256<float> value, byte control) => Permute(value, control);
/// <summary>
/// __m256d _mm256_permute_pd (__m256d a, int imm8)
/// </summary>
- public static Vector256<double> Permute(Vector256<double> value, byte control) { throw new NotImplementedException(); }
+ public static Vector256<double> Permute(Vector256<double> value, byte control) => Permute(value, control);
/// <summary>
/// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8)
/// </summary>
- public static Vector256<float> Permute2x128(Vector256<float> left, Vector256<float> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<float> Permute2x128(Vector256<float> left, Vector256<float> right, byte control) => Permute2x128(left, right, control);
/// <summary>
/// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8)
/// </summary>
- public static Vector256<double> Permute2x128(Vector256<double> left, Vector256<double> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<double> Permute2x128(Vector256<double> left, Vector256<double> right, byte control) => Permute2x128(left, right, control);
/// <summary>
/// __m128 _mm_permutevar_ps (__m128 a, __m128i b)
/// </summary>
- public static Vector128<float> PermuteVar(Vector128<float> left, Vector128<float> mask) { throw new NotImplementedException(); }
+ public static Vector128<float> PermuteVar(Vector128<float> left, Vector128<float> mask) => PermuteVar(left, mask);
/// <summary>
/// __m128d _mm_permutevar_pd (__m128d a, __m128i b)
/// </summary>
- public static Vector128<double> PermuteVar(Vector128<double> left, Vector128<double> mask) { throw new NotImplementedException(); }
+ public static Vector128<double> PermuteVar(Vector128<double> left, Vector128<double> mask) => PermuteVar(left, mask);
/// <summary>
/// __m256 _mm256_permutevar_ps (__m256 a, __m256i b)
/// </summary>
- public static Vector256<float> PermuteVar(Vector256<float> left, Vector256<float> mask) { throw new NotImplementedException(); }
+ public static Vector256<float> PermuteVar(Vector256<float> left, Vector256<float> mask) => PermuteVar(left, mask);
/// <summary>
/// __m256d _mm256_permutevar_pd (__m256d a, __m256i b)
/// </summary>
- public static Vector256<double> PermuteVar(Vector256<double> left, Vector256<double> mask) { throw new NotImplementedException(); }
+ public static Vector256<double> PermuteVar(Vector256<double> left, Vector256<double> mask) => PermuteVar(left, mask);
/// <summary>
/// __m256 _mm256_rcp_ps (__m256 a)
/// </summary>
- public static Vector256<float> Reciprocal(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<float> Reciprocal(Vector256<float> value) => Reciprocal(value);
/// <summary>
/// __m256 _mm256_rsqrt_ps (__m256 a)
/// </summary>
- public static Vector256<float> ReciprocalSqrt(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<float> ReciprocalSqrt(Vector256<float> value) => ReciprocalSqrt(value);
/// <summary>
/// __m256 _mm256_round_ps (__m256 a, int rounding)
/// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector256<float> RoundToNearestInteger(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<float> RoundToNearestInteger(Vector256<float> value) => RoundToNearestInteger(value);
/// <summary>
/// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector256<float> RoundToNegativeInfinity(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<float> RoundToNegativeInfinity(Vector256<float> value) => RoundToNegativeInfinity(value);
/// <summary>
/// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector256<float> RoundToPositiveInfinity(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<float> RoundToPositiveInfinity(Vector256<float> value) => RoundToPositiveInfinity(value);
/// <summary>
/// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector256<float> RoundToZero(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<float> RoundToZero(Vector256<float> value) => RoundToZero(value);
/// <summary>
/// _MM_FROUND_CUR_DIRECTION
/// </summary>
- public static Vector256<float> RoundCurrentDirection(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<float> RoundCurrentDirection(Vector256<float> value) => RoundCurrentDirection(value);
/// <summary>
/// __m256d _mm256_round_pd (__m256d a, int rounding)
/// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector256<double> RoundToNearestInteger(Vector256<double> value) { throw new NotImplementedException(); }
+ public static Vector256<double> RoundToNearestInteger(Vector256<double> value) => RoundToNearestInteger(value);
/// <summary>
/// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector256<double> RoundToNegativeInfinity(Vector256<double> value) { throw new NotImplementedException(); }
+ public static Vector256<double> RoundToNegativeInfinity(Vector256<double> value) => RoundToNegativeInfinity(value);
/// <summary>
/// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector256<double> RoundToPositiveInfinity(Vector256<double> value) { throw new NotImplementedException(); }
+ public static Vector256<double> RoundToPositiveInfinity(Vector256<double> value) => RoundToPositiveInfinity(value);
/// <summary>
/// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector256<double> RoundToZero(Vector256<double> value) { throw new NotImplementedException(); }
+ public static Vector256<double> RoundToZero(Vector256<double> value) => RoundToZero(value);
/// <summary>
/// _MM_FROUND_CUR_DIRECTION
/// </summary>
- public static Vector256<double> RoundCurrentDirection(Vector256<double> value) { throw new NotImplementedException(); }
+ public static Vector256<double> RoundCurrentDirection(Vector256<double> value) => RoundCurrentDirection(value);
/// <summary>
/// __m256i _mm256_set_epi8 (char e31, char e30, char e29, char e28, char e27, char e26, char e25, char e24, char e23, char e22, char e21, char e20, char e19, char e18, char e17, char e16, char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0)
/// </summary>
- public static Vector256<sbyte> Set(sbyte e31, sbyte e30, sbyte e29, sbyte e28, sbyte e27, sbyte e26, sbyte e25, sbyte e24, sbyte e23, sbyte e22, sbyte e21, sbyte e20, sbyte e19, sbyte e18, sbyte e17, sbyte e16, sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> Set(sbyte e31, sbyte e30, sbyte e29, sbyte e28, sbyte e27, sbyte e26, sbyte e25, sbyte e24, sbyte e23, sbyte e22, sbyte e21, sbyte e20, sbyte e19, sbyte e18, sbyte e17, sbyte e16, sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) => Set(e31, e30, e29, e28, e27, e26, e25, e24, e23, e22, e21, e20, e19, e18, e17, e16, e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0);
/// <summary>
/// __m256i _mm256_set_epi8 (char e31, char e30, char e29, char e28, char e27, char e26, char e25, char e24, char e23, char e22, char e21, char e20, char e19, char e18, char e17, char e16, char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0)
/// </summary>
- public static Vector256<byte> Set(byte e31, byte e30, byte e29, byte e28, byte e27, byte e26, byte e25, byte e24, byte e23, byte e22, byte e21, byte e20, byte e19, byte e18, byte e17, byte e16, byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) { throw new NotImplementedException(); }
+ public static Vector256<byte> Set(byte e31, byte e30, byte e29, byte e28, byte e27, byte e26, byte e25, byte e24, byte e23, byte e22, byte e21, byte e20, byte e19, byte e18, byte e17, byte e16, byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) => Set(e31, e30, e29, e28, e27, e26, e25, e24, e23, e22, e21, e20, e19, e18, e17, e16, e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0);
/// <summary>
/// __m256i _mm256_set_epi16 (short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0)
/// </summary>
- public static Vector256<short> Set(short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) { throw new NotImplementedException(); }
+ public static Vector256<short> Set(short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) => Set(e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0);
/// <summary>
/// __m256i _mm256_set_epi16 (short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0)
/// </summary>
- public static Vector256<ushort> Set(ushort e15, ushort e14, ushort e13, ushort e12, ushort e11, ushort e10, ushort e9, ushort e8, ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) { throw new NotImplementedException(); }
+ public static Vector256<ushort> Set(ushort e15, ushort e14, ushort e13, ushort e12, ushort e11, ushort e10, ushort e9, ushort e8, ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) => Set(e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0);
/// <summary>
/// __m256i _mm256_set_epi32 (int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0)
/// </summary>
- public static Vector256<int> Set(int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0) { throw new NotImplementedException(); }
+ public static Vector256<int> Set(int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0) => Set(e7, e6, e5, e4, e3, e2, e1, e0);
/// <summary>
/// __m256i _mm256_set_epi32 (int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0)
/// </summary>
- public static Vector256<uint> Set(uint e7, uint e6, uint e5, uint e4, uint e3, uint e2, uint e1, uint e0) { throw new NotImplementedException(); }
+ public static Vector256<uint> Set(uint e7, uint e6, uint e5, uint e4, uint e3, uint e2, uint e1, uint e0) => Set(e7, e6, e5, e4, e3, e2, e1, e0);
/// <summary>
/// __m256i _mm256_set_epi64x (__int64 e3, __int64 e2, __int64 e1, __int64 e0)
/// </summary>
- public static Vector256<long> Set(long e3, long e2, long e1, long e0) { throw new NotImplementedException(); }
+ public static Vector256<long> Set(long e3, long e2, long e1, long e0) => Set(e3, e2, e1, e0);
/// <summary>
/// __m256i _mm256_set_epi64x (__int64 e3, __int64 e2, __int64 e1, __int64 e0)
/// </summary>
- public static Vector256<ulong> Set(ulong e3, ulong e2, ulong e1, ulong e0) { throw new NotImplementedException(); }
+ public static Vector256<ulong> Set(ulong e3, ulong e2, ulong e1, ulong e0) => Set(e3, e2, e1, e0);
/// <summary>
/// __m256 _mm256_set_ps (float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0)
/// </summary>
- public static Vector256<float> Set(float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0) { throw new NotImplementedException(); }
+ public static Vector256<float> Set(float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0) => Set(e7, e6, e5, e4, e3, e2, e1, e0);
/// <summary>
/// __m256d _mm256_set_pd (double e3, double e2, double e1, double e0)
/// </summary>
- public static Vector256<double> Set(double e3, double e2, double e1, double e0) { throw new NotImplementedException(); }
+ public static Vector256<double> Set(double e3, double e2, double e1, double e0) => Set(e3, e2, e1, e0);
/// <summary>
/// __m256i _mm256_set1_epi8 (char a)
/// __m256 _mm256_set1_ps (float a)
/// __m256d _mm256_set1_pd (double a)
/// </summary>
- public static Vector256<T> Set1<T>(T value) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> Set1<T>(T value) where T : struct => Set1<T>(value);
/// <summary>
/// __m256 _mm256_set_m128 (__m128 hi, __m128 lo)
/// __m256d _mm256_set_m128d (__m128d hi, __m128d lo)
/// __m256i _mm256_set_m128i (__m128i hi, __m128i lo)
/// </summary>
- public static Vector256<T> SetHiLo<T>(Vector128<T> hi, Vector128<T> lo) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> SetHiLo<T>(Vector128<T> hi, Vector128<T> lo) where T : struct => SetHiLo<T>(hi, lo);
/// <summary>
/// __m256i _mm256_setzero_si256 (void)
/// __m256 _mm256_setzero_ps (void)
/// __m256d _mm256_setzero_pd (void)
/// </summary>
- public static Vector256<T> SetZero<T>() where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> SetZero<T>() where T : struct => SetZero<T>();
/// <summary>
/// __m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8)
/// </summary>
- public static Vector256<float> Shuffle(Vector256<float> value, Vector256<float> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<float> Shuffle(Vector256<float> value, Vector256<float> right, byte control) => Shuffle(value, right, control);
/// <summary>
/// __m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int imm8)
/// </summary>
- public static Vector256<double> Shuffle(Vector256<double> value, Vector256<double> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<double> Shuffle(Vector256<double> value, Vector256<double> right, byte control) => Shuffle(value, right, control);
/// <summary>
/// __m256 _mm256_sqrt_ps (__m256 a)
/// </summary>
- public static Vector256<float> Sqrt(Vector256<float> value) { throw new NotImplementedException(); }
+ public static Vector256<float> Sqrt(Vector256<float> value) => Sqrt(value);
/// <summary>
/// __m256d _mm256_sqrt_pd (__m256d a)
/// </summary>
- public static Vector256<double> Sqrt(Vector256<double> value) { throw new NotImplementedException(); }
+ public static Vector256<double> Sqrt(Vector256<double> value) => Sqrt(value);
/// <summary>
/// __m256 _mm256_castpd_ps (__m256d a)
/// __m256d _mm256_castsi256_pd (__m256i a)
/// __m256 _mm256_castsi256_ps (__m256i a)
/// </summary>
- public static Vector256<U> StaticCast<T, U>(Vector256<T> value) where T : struct where U : struct { throw new NotImplementedException(); }
+ public static Vector256<U> StaticCast<T, U>(Vector256<T> value) where T : struct where U : struct => StaticCast<T, U>(value);
/// <summary>
/// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAligned(sbyte* address, Vector256<sbyte> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(sbyte* address, Vector256<sbyte> source) => StoreAligned(address, source);
/// <summary>
/// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAligned(byte* address, Vector256<byte> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(byte* address, Vector256<byte> source) => StoreAligned(address, source);
/// <summary>
/// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAligned(short* address, Vector256<short> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(short* address, Vector256<short> source) => StoreAligned(address, source);
/// <summary>
/// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAligned(ushort* address, Vector256<ushort> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(ushort* address, Vector256<ushort> source) => StoreAligned(address, source);
/// <summary>
/// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAligned(int* address, Vector256<int> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(int* address, Vector256<int> source) => StoreAligned(address, source);
/// <summary>
/// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAligned(uint* address, Vector256<uint> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(uint* address, Vector256<uint> source) => StoreAligned(address, source);
/// <summary>
/// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAligned(long* address, Vector256<long> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(long* address, Vector256<long> source) => StoreAligned(address, source);
/// <summary>
/// void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAligned(ulong* address, Vector256<ulong> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(ulong* address, Vector256<ulong> source) => StoreAligned(address, source);
/// <summary>
/// void _mm256_store_ps (float * mem_addr, __m256 a)
/// </summary>
- public static unsafe void StoreAligned(float* address, Vector256<float> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(float* address, Vector256<float> source) => StoreAligned(address, source);
/// <summary>
/// void _mm256_store_pd (double * mem_addr, __m256d a)
/// </summary>
- public static unsafe void StoreAligned(double* address, Vector256<double> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(double* address, Vector256<double> source) => StoreAligned(address, source);
/// <summary>
/// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector256<sbyte> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector256<sbyte> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(byte* address, Vector256<byte> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(byte* address, Vector256<byte> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(short* address, Vector256<short> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(short* address, Vector256<short> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector256<ushort> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector256<ushort> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(int* address, Vector256<int> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(int* address, Vector256<int> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(uint* address, Vector256<uint> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(uint* address, Vector256<uint> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(long* address, Vector256<long> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(long* address, Vector256<long> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector256<ulong> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector256<ulong> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm256_stream_ps (float * mem_addr, __m256 a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(float* address, Vector256<float> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(float* address, Vector256<float> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm256_stream_pd (double * mem_addr, __m256d a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(double* address, Vector256<double> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(double* address, Vector256<double> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void Store(sbyte* address, Vector256<sbyte> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(sbyte* address, Vector256<sbyte> source) => Store(address, source);
/// <summary>
/// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void Store(byte* address, Vector256<byte> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(byte* address, Vector256<byte> source) => Store(address, source);
/// <summary>
/// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void Store(short* address, Vector256<short> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(short* address, Vector256<short> source) => Store(address, source);
/// <summary>
/// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void Store(ushort* address, Vector256<ushort> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(ushort* address, Vector256<ushort> source) => Store(address, source);
/// <summary>
/// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void Store(int* address, Vector256<int> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(int* address, Vector256<int> source) => Store(address, source);
/// <summary>
/// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void Store(uint* address, Vector256<uint> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(uint* address, Vector256<uint> source) => Store(address, source);
/// <summary>
/// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void Store(long* address, Vector256<long> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(long* address, Vector256<long> source) => Store(address, source);
/// <summary>
/// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
/// </summary>
- public static unsafe void Store(ulong* address, Vector256<ulong> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(ulong* address, Vector256<ulong> source) => Store(address, source);
/// <summary>
/// void _mm256_storeu_ps (float * mem_addr, __m256 a)
/// </summary>
- public static unsafe void Store(float* address, Vector256<float> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(float* address, Vector256<float> source) => Store(address, source);
/// <summary>
/// void _mm256_storeu_pd (double * mem_addr, __m256d a)
/// </summary>
- public static unsafe void Store(double* address, Vector256<double> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(double* address, Vector256<double> source) => Store(address, source);
/// <summary>
/// __m256 _mm256_sub_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> Subtract(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> Subtract(Vector256<float> left, Vector256<float> right) => Subtract(left, right);
/// <summary>
/// __m256d _mm256_sub_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> Subtract(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> Subtract(Vector256<double> left, Vector256<double> right) => Subtract(left, right);
/// <summary>
/// int _mm_testc_ps (__m128 a, __m128 b)
/// </summary>
- public static bool TestC(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static bool TestC(Vector128<float> left, Vector128<float> right) => TestC(left, right);
/// <summary>
/// int _mm_testc_pd (__m128d a, __m128d b)
/// </summary>
- public static bool TestC(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static bool TestC(Vector128<double> left, Vector128<double> right) => TestC(left, right);
/// <summary>
/// int _mm256_testc_si256 (__m256i a, __m256i b)
/// int _mm256_testc_ps (__m256 a, __m256 b)
/// int _mm256_testc_pd (__m256d a, __m256d b)
/// </summary>
- public static bool TestC<T>(Vector256<T> left, Vector256<T> right) where T : struct { throw new NotImplementedException(); }
+ public static bool TestC<T>(Vector256<T> left, Vector256<T> right) where T : struct => TestC<T>(left, right);
/// <summary>
/// int _mm_testnzc_ps (__m128 a, __m128 b)
/// </summary>
- public static bool TestNotZAndNotC(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static bool TestNotZAndNotC(Vector128<float> left, Vector128<float> right) => TestNotZAndNotC(left, right);
/// <summary>
/// int _mm_testnzc_pd (__m128d a, __m128d b)
/// </summary>
- public static bool TestNotZAndNotC(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static bool TestNotZAndNotC(Vector128<double> left, Vector128<double> right) => TestNotZAndNotC(left, right);
/// <summary>
/// int _mm256_testnzc_si256 (__m256i a, __m256i b)
/// int _mm256_testnzc_ps (__m256 a, __m256 b)
/// int _mm256_testnzc_pd (__m256d a, __m256d b)
/// </summary>
- public static bool TestNotZAndNotC<T>(Vector256<T> left, Vector256<T> right) where T : struct { throw new NotImplementedException(); }
+ public static bool TestNotZAndNotC<T>(Vector256<T> left, Vector256<T> right) where T : struct => TestNotZAndNotC<T>(left, right);
/// <summary>
/// int _mm_testz_ps (__m128 a, __m128 b)
/// </summary>
- public static bool TestZ(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static bool TestZ(Vector128<float> left, Vector128<float> right) => TestZ(left, right);
/// <summary>
/// int _mm_testz_ps (__m128 a, __m128 b)
/// </summary>
- public static bool TestZ(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static bool TestZ(Vector128<double> left, Vector128<double> right) => TestZ(left, right);
/// <summary>
/// int _mm256_testz_si256 (__m256i a, __m256i b)
/// int _mm256_testz_ps (__m256 a, __m256 b)
/// int _mm256_testz_pd (__m256d a, __m256d b)
/// </summary>
- public static bool TestZ<T>(Vector256<T> left, Vector256<T> right) where T : struct { throw new NotImplementedException(); }
+ public static bool TestZ<T>(Vector256<T> left, Vector256<T> right) where T : struct => TestZ<T>(left, right);
/// <summary>
/// __m256 _mm256_unpackhi_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> UnpackHigh(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> UnpackHigh(Vector256<float> left, Vector256<float> right) => UnpackHigh(left, right);
/// <summary>
/// __m256d _mm256_unpackhi_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> UnpackHigh(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> UnpackHigh(Vector256<double> left, Vector256<double> right) => UnpackHigh(left, right);
/// <summary>
/// __m256 _mm256_unpacklo_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> UnpackLow(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> UnpackLow(Vector256<float> left, Vector256<float> right) => UnpackLow(left, right);
/// <summary>
/// __m256d _mm256_unpacklo_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> UnpackLow(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> UnpackLow(Vector256<double> left, Vector256<double> right) => UnpackLow(left, right);
/// <summary>
/// __m256 _mm256_xor_ps (__m256 a, __m256 b)
/// </summary>
- public static Vector256<float> Xor(Vector256<float> left, Vector256<float> right) { throw new NotImplementedException(); }
+ public static Vector256<float> Xor(Vector256<float> left, Vector256<float> right) => Xor(left, right);
/// <summary>
/// __m256d _mm256_xor_pd (__m256d a, __m256d b)
/// </summary>
- public static Vector256<double> Xor(Vector256<double> left, Vector256<double> right) { throw new NotImplementedException(); }
+ public static Vector256<double> Xor(Vector256<double> left, Vector256<double> right) => Xor(left, right);
/// <summary>
/// void _mm256_zeroall (void)
/// </summary>
- public static void ZeroAll() { throw new NotImplementedException(); }
+ public static void ZeroAll() => ZeroAll();
/// <summary>
/// void _mm256_zeroupper (void)
/// </summary>
- public static void ZeroUpper() { throw new NotImplementedException(); }
+ public static void ZeroUpper() => ZeroUpper();
/// <summary>
/// __m256d _mm256_zextpd128_pd256 (__m128d a)
/// __m256 _mm256_zextps128_ps256 (__m128 a)
/// __m256i _mm256_zextsi128_si256 (__m128i a)
/// </summary>
- public static Vector256<T> ZeroExtendToVector256<T>(Vector128<T> value) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> ZeroExtendToVector256<T>(Vector128<T> value) where T : struct => ZeroExtendToVector256<T>(value);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel AVX2 hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Avx2
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// __m256i _mm256_abs_epi8 (__m256i a)
+ /// </summary>
+ public static Vector256<byte> Abs(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_abs_epi16 (__m256i a)
+ /// </summary>
+ public static Vector256<ushort> Abs(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_abs_epi32 (__m256i a)
+ /// </summary>
+ public static Vector256<uint> Abs(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_add_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> Add(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_add_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> Add(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_add_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> Add(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_add_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> Add(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_add_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> Add(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_add_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<uint> Add(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_add_epi64 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<long> Add(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_add_epi64 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ulong> Add(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_adds_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_adds_epu8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_adds_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_adds_epu16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
+ /// </summary>
+ public static Vector256<sbyte> AlignRight(Vector256<sbyte> left, Vector256<sbyte> right, byte mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_and_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> And(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_and_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> And(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_and_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> And(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_and_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> And(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_and_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> And(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_and_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<uint> And(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_and_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<long> And(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_and_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ulong> And(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> AndNot(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> AndNot(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> AndNot(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> AndNot(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> AndNot(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<uint> AndNot(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<long> AndNot(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ulong> AndNot(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_avg_epu8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> Average(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_avg_epu16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> Average(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<int> Blend(Vector128<int> left, Vector128<int> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<uint> Blend(Vector128<uint> left, Vector128<uint> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<short> Blend(Vector256<short> left, Vector256<short> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<ushort> Blend(Vector256<ushort> left, Vector256<ushort> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<int> Blend(Vector256<int> left, Vector256<int> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<uint> Blend(Vector256<uint> left, Vector256<uint> right, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask)
+ /// </summary>
+ public static Vector256<sbyte> BlendVariable(Vector256<sbyte> left, Vector256<sbyte> right, Vector256<sbyte> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask)
+ /// </summary>
+ public static Vector256<byte> BlendVariable(Vector256<byte> left, Vector256<byte> right, Vector256<byte> mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_broadcastb_epi8 (__m128i a)
+ /// __m128i _mm_broadcastw_epi16 (__m128i a)
+ /// __m128i _mm_broadcastd_epi32 (__m128i a)
+ /// __m128i _mm_broadcastq_epi64 (__m128i a)
+ /// __m128 _mm_broadcastss_ps (__m128 a)
+ /// __m128d _mm_broadcastsd_pd (__m128d a)
+ /// </summary>
+ public static Vector128<T> BroadcastElementToVector128<T>(Vector128<T> value) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_broadcastb_epi8 (__m128i a)
+ /// __m256i _mm256_broadcastw_epi16 (__m128i a)
+ /// __m256i _mm256_broadcastd_epi32 (__m128i a)
+ /// __m256i _mm256_broadcastq_epi64 (__m128i a)
+ /// __m256 _mm256_broadcastss_ps (__m128 a)
+ /// __m256d _mm256_broadcastsd_pd (__m128d a)
+ /// </summary>
+ public static Vector256<T> BroadcastElementToVector256<T>(Vector128<T> value) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_broadcastsi128_si256 (__m128i a)
+ /// </summary>
+ public static unsafe Vector256<sbyte> BroadcastVector128ToVector256(sbyte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_broadcastsi128_si256 (__m128i a)
+ /// </summary>
+ public static unsafe Vector256<byte> BroadcastVector128ToVector256(byte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_broadcastsi128_si256 (__m128i a)
+ /// </summary>
+ public static unsafe Vector256<short> BroadcastVector128ToVector256(short* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_broadcastsi128_si256 (__m128i a)
+ /// </summary>
+ public static unsafe Vector256<ushort> BroadcastVector128ToVector256(ushort* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_broadcastsi128_si256 (__m128i a)
+ /// </summary>
+ public static unsafe Vector256<int> BroadcastVector128ToVector256(int* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_broadcastsi128_si256 (__m128i a)
+ /// </summary>
+ public static unsafe Vector256<uint> BroadcastVector128ToVector256(uint* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_broadcastsi128_si256 (__m128i a)
+ /// </summary>
+ public static unsafe Vector256<long> BroadcastVector128ToVector256(long* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_broadcastsi128_si256 (__m128i a)
+ /// </summary>
+ public static unsafe Vector256<ulong> BroadcastVector128ToVector256(ulong* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<long> CompareEqual(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ulong> CompareEqual(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_cmpgt_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cmpgt_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cmpgt_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cmpgt_epi64 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_cvtepi8_epi16 (__m128i a)
+ /// </summary>
+ public static Vector256<short> ConvertToVector256Short(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvtepu8_epi16 (__m128i a)
+ /// </summary>
+ public static Vector256<ushort> ConvertToVector256UShort(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvtepi8_epi32 (__m128i a)
+ /// </summary>
+ public static Vector256<int> ConvertToVector256Int(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvtepi16_epi32 (__m128i a)
+ /// </summary>
+ public static Vector256<int> ConvertToVector256Int(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvtepu8_epi32 (__m128i a)
+ /// </summary>
+ public static Vector256<uint> ConvertToVector256UInt(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvtepu16_epi32 (__m128i a)
+ /// </summary>
+ public static Vector256<uint> ConvertToVector256UInt(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvtepi8_epi64 (__m128i a)
+ /// </summary>
+ public static Vector256<long> ConvertToVector256Long(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvtepi16_epi64 (__m128i a)
+ /// </summary>
+ public static Vector256<long> ConvertToVector256Long(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvtepi32_epi64 (__m128i a)
+ /// </summary>
+ public static Vector256<long> ConvertToVector256Long(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvtepu8_epi64 (__m128i a)
+ /// </summary>
+ public static Vector256<ulong> ConvertToVector256ULong(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvtepu16_epi64 (__m128i a)
+ /// </summary>
+ public static Vector256<ulong> ConvertToVector256ULong(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_cvtepu32_epi64 (__m128i a)
+ /// </summary>
+ public static Vector256<ulong> ConvertToVector256ULong(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+ // <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(sbyte* address, Vector256<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(byte* address, Vector256<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector128<short> ExtractVector128(Vector256<short> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(short* address, Vector256<short> value, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(ushort* address, Vector256<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector128<int> ExtractVector128(Vector256<int> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(int* address, Vector256<int> value, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(uint* address, Vector256<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector128<long> ExtractVector128(Vector256<long> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(long* address, Vector256<long> value, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
+ /// </summary>
+ public static unsafe void ExtractVector128(ulong* address, Vector256<ulong> value, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128 _mm_i32gather_ps (float const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_i32gather_pd (double const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128 _mm_i64gather_ps (float const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_i64gather_pd (double const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector256<int> GatherVector256(int* baseAddress, Vector256<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector256<uint> GatherVector256(uint* baseAddress, Vector256<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_i32gather_ps (float const* base_addr, __m256i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector256<float> GatherVector256(float* baseAddress, Vector256<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_i32gather_pd (double const* base_addr, __m128i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector256<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector256<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector256<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector256<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128 _mm256_i64gather_ps (float const* base_addr, __m256i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector256<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_i64gather_pd (double const* base_addr, __m256i vindex, const int scale)
+ /// </summary>
+ public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector256<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<int> index, Vector128<int> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<int> index, Vector128<uint> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<int> index, Vector128<long> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<int> index, Vector128<ulong> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128 _mm_mask_i32gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<int> index, Vector128<float> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_mask_i32gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<int> index, Vector128<double> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<long> index, Vector128<int> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<long> index, Vector128<uint> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<long> index, Vector128<long> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<long> index, Vector128<ulong> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128 _mm_mask_i64gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<long> index, Vector128<float> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_mask_i64gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<long> index, Vector128<double> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector256<int> GatherMaskVector256(Vector256<int> source, int* baseAddress, Vector256<int> index, Vector256<int> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector256<uint> GatherMaskVector256(Vector256<uint> source, uint* baseAddress, Vector256<int> index, Vector256<uint> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector128<int> index, Vector256<long> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector128<int> index, Vector256<ulong> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_mask_i32gather_ps (__m256 src, float const* base_addr, __m256i vindex, __m256 mask, const int scale)
+ /// </summary>
+ public static unsafe Vector256<float> GatherMaskVector256(Vector256<float> source, float* baseAddress, Vector256<int> index, Vector256<float> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_mask_i32gather_pd (__m256d src, double const* base_addr, __m128i vindex, __m256d mask, const int scale)
+ /// </summary>
+ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector128<int> index, Vector256<double> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector256<long> index, Vector128<int> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector256<long> index, Vector128<uint> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector256<long> index, Vector256<long> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale)
+ /// </summary>
+ public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector256<long> index, Vector256<ulong> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128 _mm256_mask_i64gather_ps (__m128 src, float const* base_addr, __m256i vindex, __m128 mask, const int scale)
+ /// </summary>
+ public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector256<long> index, Vector128<float> mask, byte scale) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_mask_i64gather_pd (__m256d src, double const* base_addr, __m256i vindex, __m256d mask, const int scale)
+ /// </summary>
+ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector256<long> index, Vector256<double> mask, byte scale) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_hadd_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> HorizontalAdd(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_hadd_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> HorizontalAdd(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_hadds_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> HorizontalAddSaturate(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_hsub_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> HorizontalSubtract(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_hsub_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> HorizontalSubtract(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_hsubs_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> HorizontalSubtractSaturate(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector256<sbyte> Insert(Vector256<sbyte> value, Vector128<sbyte> data, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static unsafe Vector256<sbyte> Insert(Vector256<sbyte> value, sbyte* address, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector256<byte> Insert(Vector256<byte> value, Vector128<byte> data, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static unsafe Vector256<byte> Insert(Vector256<byte> value, byte* address, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector256<short> Insert(Vector256<short> value, Vector128<short> data, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static unsafe Vector256<short> Insert(Vector256<short> value, short* address, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector256<ushort> Insert(Vector256<ushort> value, Vector128<ushort> data, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static unsafe Vector256<ushort> Insert(Vector256<ushort> value, ushort* address, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector256<int> Insert(Vector256<int> value, Vector128<int> data, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static unsafe Vector256<int> Insert(Vector256<int> value, int* address, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector256<uint> Insert(Vector256<uint> value, Vector128<uint> data, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static unsafe Vector256<uint> Insert(Vector256<uint> value, uint* address, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector256<long> Insert(Vector256<long> value, Vector128<long> data, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static unsafe Vector256<long> Insert(Vector256<long> value, long* address, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector256<ulong> Insert(Vector256<ulong> value, Vector128<ulong> data, byte index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
+ /// </summary>
+ public static unsafe Vector256<ulong> Insert(Vector256<ulong> value, ulong* address, byte index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask)
+ /// </summary>
+ public static unsafe Vector128<int> MaskLoad(int* address, Vector128<int> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask)
+ /// </summary>
+ public static unsafe Vector128<uint> MaskLoad(uint* address, Vector128<uint> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask)
+ /// </summary>
+ public static unsafe Vector128<long> MaskLoad(long* address, Vector128<long> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask)
+ /// </summary>
+ public static unsafe Vector128<ulong> MaskLoad(ulong* address, Vector128<ulong> mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask)
+ /// </summary>
+ public static unsafe Vector256<int> MaskLoad(int* address, Vector256<int> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask)
+ /// </summary>
+ public static unsafe Vector256<uint> MaskLoad(uint* address, Vector256<uint> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask)
+ /// </summary>
+ public static unsafe Vector256<long> MaskLoad(long* address, Vector256<long> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask)
+ /// </summary>
+ public static unsafe Vector256<ulong> MaskLoad(ulong* address, Vector256<ulong> mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a)
+ /// </summary>
+ public static unsafe void MaskStore(int* address, Vector128<int> mask, Vector128<int> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a)
+ /// </summary>
+ public static unsafe void MaskStore(uint* address, Vector128<uint> mask, Vector128<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a)
+ /// </summary>
+ public static unsafe void MaskStore(long* address, Vector128<long> mask, Vector128<long> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a)
+ /// </summary>
+ public static unsafe void MaskStore(ulong* address, Vector128<ulong> mask, Vector128<ulong> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a)
+ /// </summary>
+ public static unsafe void MaskStore(int* address, Vector256<int> mask, Vector256<int> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a)
+ /// </summary>
+ public static unsafe void MaskStore(uint* address, Vector256<uint> mask, Vector256<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a)
+ /// </summary>
+ public static unsafe void MaskStore(long* address, Vector256<long> mask, Vector256<long> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a)
+ /// </summary>
+ public static unsafe void MaskStore(ulong* address, Vector256<ulong> mask, Vector256<ulong> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_madd_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> MultiplyAddAdjacent(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_maddubs_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> MultiplyAddAdjacent(Vector256<byte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_max_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> Max(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_max_epu8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> Max(Vector256<byte> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_max_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> Max(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_max_epu16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> Max(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_max_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> Max(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_max_epu32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<uint> Max(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_min_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> Min(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_min_epu8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> Min(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_min_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> Min(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_min_epu16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> Min(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_min_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> Min(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_min_epu32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<uint> Min(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm256_movemask_epi8 (__m256i a)
+ /// </summary>
+ public static int MoveMask(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// int _mm256_movemask_epi8 (__m256i a)
+ /// </summary>
+ public static int MoveMask(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_mpsadbw_epu8 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<ushort> MultipleSumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right, byte mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_mul_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<long> Multiply(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_mul_epu32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ulong> Multiply(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_mulhi_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> MultiplyHigh(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_mulhi_epu16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> MultiplyHigh(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_mulhrs_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> MultiplyHighRoundScale(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_mullo_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> MultiplyLow(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_mullo_epu16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> MultiplyLow(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_or_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> Or(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_or_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> Or(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_or_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> Or(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_or_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> Or(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_or_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> Or(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_or_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<uint> Or(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_or_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<long> Or(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_or_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ulong> Or(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_packs_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> PackSignedSaturate(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_packs_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> PackSignedSaturate(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_packus_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> PackUnsignedSaturate(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_packus_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> PackUnsignedSaturate(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
+ /// </summary>
+ public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<long> Permute4x64(Vector256<long> value, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<ulong> Permute4x64(Vector256<ulong> value, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_permute4x64_pd (__m256d a, const int imm8)
+ /// </summary>
+ public static Vector256<double> Permute4x64(Vector256<double> value, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx)
+ /// </summary>
+ public static Vector256<int> PermuteVar8x32(Vector256<int> left, Vector256<int> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx)
+ /// </summary>
+ public static Vector256<uint> PermuteVar8x32(Vector256<uint> left, Vector256<uint> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_permutevar8x32_ps (__m256 a, __m256i idx)
+ /// </summary>
+ public static Vector256<float> PermuteVar8x32(Vector256<float> left, Vector256<float> mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_slli_epi16 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<short> ShiftLeftLogical(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_slli_epi16 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_slli_epi32 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<int> ShiftLeftLogical(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_slli_epi32 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_slli_epi64 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<long> ShiftLeftLogical(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_slli_epi64 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<sbyte> ShiftLeftLogical128BitLane(Vector256<sbyte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<byte> ShiftLeftLogical128BitLane(Vector256<byte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<short> ShiftLeftLogical128BitLane(Vector256<short> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<ushort> ShiftLeftLogical128BitLane(Vector256<ushort> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<int> ShiftLeftLogical128BitLane(Vector256<int> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<uint> ShiftLeftLogical128BitLane(Vector256<uint> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<long> ShiftLeftLogical128BitLane(Vector256<long> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<ulong> ShiftLeftLogical128BitLane(Vector256<ulong> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count)
+ /// </summary>
+ public static Vector256<int> ShiftLeftLogicalVariable(Vector256<int> value, Vector256<uint> count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count)
+ /// </summary>
+ public static Vector256<uint> ShiftLeftLogicalVariable(Vector256<uint> value, Vector256<uint> count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count)
+ /// </summary>
+ public static Vector256<long> ShiftLeftLogicalVariable(Vector256<long> value, Vector256<ulong> count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count)
+ /// </summary>
+ public static Vector256<ulong> ShiftLeftLogicalVariable(Vector256<ulong> value, Vector256<ulong> count) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_srai_epi16 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_srai_epi32 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_srav_epi32 (__m256i a, __m256i count)
+ /// </summary>
+ public static Vector256<int> ShiftRightArithmeticVariable(Vector256<int> value, Vector256<uint> count) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_srli_epi16 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<short> ShiftRightLogical(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_srli_epi16 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_srli_epi32 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<int> ShiftRightLogical(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_srli_epi32 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_srli_epi64 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<long> ShiftRightLogical(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_srli_epi64 (__m256i a, int imm8)
+ /// </summary>
+ public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<sbyte> ShiftRightLogical128BitLane(Vector256<sbyte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<byte> ShiftRightLogical128BitLane(Vector256<byte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<short> ShiftRightLogical128BitLane(Vector256<short> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<ushort> ShiftRightLogical128BitLane(Vector256<ushort> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<int> ShiftRightLogical128BitLane(Vector256<int> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<uint> ShiftRightLogical128BitLane(Vector256<uint> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<long> ShiftRightLogical128BitLane(Vector256<long> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<ulong> ShiftRightLogical128BitLane(Vector256<ulong> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count)
+ /// </summary>
+ public static Vector256<int> ShiftRightLogicalVariable(Vector256<int> value, Vector256<uint> count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count)
+ /// </summary>
+ public static Vector256<uint> ShiftRightLogicalVariable(Vector256<uint> value, Vector256<uint> count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count)
+ /// </summary>
+ public static Vector256<long> ShiftRightLogicalVariable(Vector256<long> value, Vector256<ulong> count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count)
+ /// </summary>
+ public static Vector256<ulong> ShiftRightLogicalVariable(Vector256<ulong> value, Vector256<ulong> count) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> Shuffle(Vector256<sbyte> value, Vector256<sbyte> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> Shuffle(Vector256<byte> value, Vector256<byte> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<int> Shuffle(Vector256<int> value, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<uint> Shuffle(Vector256<uint> value, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<short> ShuffleHigh(Vector256<short> value, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<ushort> ShuffleHigh(Vector256<ushort> value, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<short> ShuffleLow(Vector256<short> value, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8)
+ /// </summary>
+ public static Vector256<ushort> ShuffleLow(Vector256<ushort> value, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_sign_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> Sign(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_sign_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> Sign(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_sign_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> Sign(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> Subtract(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> Subtract(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> Subtract(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> Subtract(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<long> Subtract(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ulong> Subtract(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_subs_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> SubtractSaturate(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_subs_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> SubtractSaturate(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_subs_epu8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> SubtractSaturate(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_subs_epu16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> SubtractSaturate(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_sad_epu8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ulong> SumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> UnpackHigh(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> UnpackHigh(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> UnpackHigh(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> UnpackHigh(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> UnpackHigh(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<uint> UnpackHigh(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<long> UnpackHigh(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ulong> UnpackHigh(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> UnpackLow(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> UnpackLow(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> UnpackLow(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> UnpackLow(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> UnpackLow(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<uint> UnpackLow(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<long> UnpackLow(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ulong> UnpackLow(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<sbyte> Xor(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<byte> Xor(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<short> Xor(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ushort> Xor(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<int> Xor(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<uint> Xor(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<long> Xor(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
+ /// </summary>
+ public static Vector256<ulong> Xor(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+ }
+}
[CLSCompliant(false)]
public static class Avx2
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// __m256i _mm256_abs_epi8 (__m256i a)
/// </summary>
- public static Vector256<byte> Abs(Vector256<sbyte> value) { throw new NotImplementedException(); }
+ public static Vector256<byte> Abs(Vector256<sbyte> value) => Abs(value);
/// <summary>
/// __m256i _mm256_abs_epi16 (__m256i a)
/// </summary>
- public static Vector256<ushort> Abs(Vector256<short> value) { throw new NotImplementedException(); }
+ public static Vector256<ushort> Abs(Vector256<short> value) => Abs(value);
/// <summary>
/// __m256i _mm256_abs_epi32 (__m256i a)
/// </summary>
- public static Vector256<uint> Abs(Vector256<int> value) { throw new NotImplementedException(); }
+ public static Vector256<uint> Abs(Vector256<int> value) => Abs(value);
/// <summary>
/// __m256i _mm256_add_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> Add(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> Add(Vector256<sbyte> left, Vector256<sbyte> right) => Add(left, right);
/// <summary>
/// __m256i _mm256_add_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> Add(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> Add(Vector256<byte> left, Vector256<byte> right) => Add(left, right);
/// <summary>
/// __m256i _mm256_add_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> Add(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> Add(Vector256<short> left, Vector256<short> right) => Add(left, right);
/// <summary>
/// __m256i _mm256_add_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> Add(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> Add(Vector256<ushort> left, Vector256<ushort> right) => Add(left, right);
/// <summary>
/// __m256i _mm256_add_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> Add(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> Add(Vector256<int> left, Vector256<int> right) => Add(left, right);
/// <summary>
/// __m256i _mm256_add_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<uint> Add(Vector256<uint> left, Vector256<uint> right) { throw new NotImplementedException(); }
+ public static Vector256<uint> Add(Vector256<uint> left, Vector256<uint> right) => Add(left, right);
/// <summary>
/// __m256i _mm256_add_epi64 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<long> Add(Vector256<long> left, Vector256<long> right) { throw new NotImplementedException(); }
+ public static Vector256<long> Add(Vector256<long> left, Vector256<long> right) => Add(left, right);
/// <summary>
/// __m256i _mm256_add_epi64 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ulong> Add(Vector256<ulong> left, Vector256<ulong> right) { throw new NotImplementedException(); }
+ public static Vector256<ulong> Add(Vector256<ulong> left, Vector256<ulong> right) => Add(left, right);
/// <summary>
/// __m256i _mm256_adds_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<sbyte> right) => AddSaturate(left, right);
/// <summary>
/// __m256i _mm256_adds_epu8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<byte> right) => AddSaturate(left, right);
/// <summary>
/// __m256i _mm256_adds_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<short> right) => AddSaturate(left, right);
/// <summary>
/// __m256i _mm256_adds_epu16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<ushort> right) => AddSaturate(left, right);
/// <summary>
/// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
/// </summary>
- public static Vector256<sbyte> AlignRight(Vector256<sbyte> left, Vector256<sbyte> right, byte mask) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> AlignRight(Vector256<sbyte> left, Vector256<sbyte> right, byte mask) => AlignRight(left, right, mask);
/// <summary>
/// __m256i _mm256_and_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> And(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> And(Vector256<sbyte> left, Vector256<sbyte> right) => And(left, right);
/// <summary>
/// __m256i _mm256_and_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> And(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> And(Vector256<byte> left, Vector256<byte> right) => And(left, right);
/// <summary>
/// __m256i _mm256_and_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> And(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> And(Vector256<short> left, Vector256<short> right) => And(left, right);
/// <summary>
/// __m256i _mm256_and_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> And(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> And(Vector256<ushort> left, Vector256<ushort> right) => And(left, right);
/// <summary>
/// __m256i _mm256_and_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> And(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> And(Vector256<int> left, Vector256<int> right) => And(left, right);
/// <summary>
/// __m256i _mm256_and_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<uint> And(Vector256<uint> left, Vector256<uint> right) { throw new NotImplementedException(); }
+ public static Vector256<uint> And(Vector256<uint> left, Vector256<uint> right) => And(left, right);
/// <summary>
/// __m256i _mm256_and_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<long> And(Vector256<long> left, Vector256<long> right) { throw new NotImplementedException(); }
+ public static Vector256<long> And(Vector256<long> left, Vector256<long> right) => And(left, right);
/// <summary>
/// __m256i _mm256_and_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ulong> And(Vector256<ulong> left, Vector256<ulong> right) { throw new NotImplementedException(); }
+ public static Vector256<ulong> And(Vector256<ulong> left, Vector256<ulong> right) => And(left, right);
/// <summary>
/// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> AndNot(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> AndNot(Vector256<sbyte> left, Vector256<sbyte> right) => AndNot(left, right);
/// <summary>
/// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> AndNot(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> AndNot(Vector256<byte> left, Vector256<byte> right) => AndNot(left, right);
/// <summary>
/// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> AndNot(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> AndNot(Vector256<short> left, Vector256<short> right) => AndNot(left, right);
/// <summary>
/// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> AndNot(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> AndNot(Vector256<ushort> left, Vector256<ushort> right) => AndNot(left, right);
/// <summary>
/// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> AndNot(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> AndNot(Vector256<int> left, Vector256<int> right) => AndNot(left, right);
/// <summary>
/// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<uint> AndNot(Vector256<uint> left, Vector256<uint> right) { throw new NotImplementedException(); }
+ public static Vector256<uint> AndNot(Vector256<uint> left, Vector256<uint> right) => AndNot(left, right);
/// <summary>
/// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<long> AndNot(Vector256<long> left, Vector256<long> right) { throw new NotImplementedException(); }
+ public static Vector256<long> AndNot(Vector256<long> left, Vector256<long> right) => AndNot(left, right);
/// <summary>
/// __m256i _mm256_andnot_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ulong> AndNot(Vector256<ulong> left, Vector256<ulong> right) { throw new NotImplementedException(); }
+ public static Vector256<ulong> AndNot(Vector256<ulong> left, Vector256<ulong> right) => AndNot(left, right);
/// <summary>
/// __m256i _mm256_avg_epu8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> Average(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> Average(Vector256<byte> left, Vector256<byte> right) => Average(left, right);
/// <summary>
/// __m256i _mm256_avg_epu16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> Average(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> Average(Vector256<ushort> left, Vector256<ushort> right) => Average(left, right);
/// <summary>
/// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<int> Blend(Vector128<int> left, Vector128<int> right, byte control) { throw new NotImplementedException(); }
+ public static Vector128<int> Blend(Vector128<int> left, Vector128<int> right, byte control) => Blend(left, right, control);
/// <summary>
/// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<uint> Blend(Vector128<uint> left, Vector128<uint> right, byte control) { throw new NotImplementedException(); }
+ public static Vector128<uint> Blend(Vector128<uint> left, Vector128<uint> right, byte control) => Blend(left, right, control);
/// <summary>
/// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<short> Blend(Vector256<short> left, Vector256<short> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<short> Blend(Vector256<short> left, Vector256<short> right, byte control) => Blend(left, right, control);
/// <summary>
/// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<ushort> Blend(Vector256<ushort> left, Vector256<ushort> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<ushort> Blend(Vector256<ushort> left, Vector256<ushort> right, byte control) => Blend(left, right, control);
/// <summary>
/// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<int> Blend(Vector256<int> left, Vector256<int> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<int> Blend(Vector256<int> left, Vector256<int> right, byte control) => Blend(left, right, control);
/// <summary>
/// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<uint> Blend(Vector256<uint> left, Vector256<uint> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<uint> Blend(Vector256<uint> left, Vector256<uint> right, byte control) => Blend(left, right, control);
/// <summary>
/// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask)
/// </summary>
- public static Vector256<sbyte> BlendVariable(Vector256<sbyte> left, Vector256<sbyte> right, Vector256<sbyte> mask) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> BlendVariable(Vector256<sbyte> left, Vector256<sbyte> right, Vector256<sbyte> mask) => BlendVariable(left, right, mask);
/// <summary>
/// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask)
/// </summary>
- public static Vector256<byte> BlendVariable(Vector256<byte> left, Vector256<byte> right, Vector256<byte> mask) { throw new NotImplementedException(); }
+ public static Vector256<byte> BlendVariable(Vector256<byte> left, Vector256<byte> right, Vector256<byte> mask) => BlendVariable(left, right, mask);
/// <summary>
/// __m128i _mm_broadcastb_epi8 (__m128i a)
/// __m128 _mm_broadcastss_ps (__m128 a)
/// __m128d _mm_broadcastsd_pd (__m128d a)
/// </summary>
- public static Vector128<T> BroadcastElementToVector128<T>(Vector128<T> value) where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> BroadcastElementToVector128<T>(Vector128<T> value) where T : struct => BroadcastElementToVector128<T>(value);
/// <summary>
/// __m256i _mm256_broadcastb_epi8 (__m128i a)
/// __m256 _mm256_broadcastss_ps (__m128 a)
/// __m256d _mm256_broadcastsd_pd (__m128d a)
/// </summary>
- public static Vector256<T> BroadcastElementToVector256<T>(Vector128<T> value) where T : struct { throw new NotImplementedException(); }
+ public static Vector256<T> BroadcastElementToVector256<T>(Vector128<T> value) where T : struct => BroadcastElementToVector256<T>(value);
/// <summary>
/// __m256i _mm256_broadcastsi128_si256 (__m128i a)
/// </summary>
- public static unsafe Vector256<sbyte> BroadcastVector128ToVector256(sbyte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<sbyte> BroadcastVector128ToVector256(sbyte* address) => BroadcastVector128ToVector256(address);
/// <summary>
/// __m256i _mm256_broadcastsi128_si256 (__m128i a)
/// </summary>
- public static unsafe Vector256<byte> BroadcastVector128ToVector256(byte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<byte> BroadcastVector128ToVector256(byte* address) => BroadcastVector128ToVector256(address);
/// <summary>
/// __m256i _mm256_broadcastsi128_si256 (__m128i a)
/// </summary>
- public static unsafe Vector256<short> BroadcastVector128ToVector256(short* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<short> BroadcastVector128ToVector256(short* address) => BroadcastVector128ToVector256(address);
/// <summary>
/// __m256i _mm256_broadcastsi128_si256 (__m128i a)
/// </summary>
- public static unsafe Vector256<ushort> BroadcastVector128ToVector256(ushort* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ushort> BroadcastVector128ToVector256(ushort* address) => BroadcastVector128ToVector256(address);
/// <summary>
/// __m256i _mm256_broadcastsi128_si256 (__m128i a)
/// </summary>
- public static unsafe Vector256<int> BroadcastVector128ToVector256(int* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<int> BroadcastVector128ToVector256(int* address) => BroadcastVector128ToVector256(address);
/// <summary>
/// __m256i _mm256_broadcastsi128_si256 (__m128i a)
/// </summary>
- public static unsafe Vector256<uint> BroadcastVector128ToVector256(uint* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<uint> BroadcastVector128ToVector256(uint* address) => BroadcastVector128ToVector256(address);
/// <summary>
/// __m256i _mm256_broadcastsi128_si256 (__m128i a)
/// </summary>
- public static unsafe Vector256<long> BroadcastVector128ToVector256(long* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<long> BroadcastVector128ToVector256(long* address) => BroadcastVector128ToVector256(address);
/// <summary>
/// __m256i _mm256_broadcastsi128_si256 (__m128i a)
/// </summary>
- public static unsafe Vector256<ulong> BroadcastVector128ToVector256(ulong* address) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ulong> BroadcastVector128ToVector256(ulong* address) => BroadcastVector128ToVector256(address);
/// <summary>
/// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareEqual(left, right);
/// <summary>
/// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right) => CompareEqual(left, right);
/// <summary>
/// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right) => CompareEqual(left, right);
/// <summary>
/// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareEqual(left, right);
/// <summary>
/// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right) => CompareEqual(left, right);
/// <summary>
/// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right) { throw new NotImplementedException(); }
+ public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right) => CompareEqual(left, right);
/// <summary>
/// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<long> CompareEqual(Vector256<long> left, Vector256<long> right) { throw new NotImplementedException(); }
+ public static Vector256<long> CompareEqual(Vector256<long> left, Vector256<long> right) => CompareEqual(left, right);
/// <summary>
/// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ulong> CompareEqual(Vector256<ulong> left, Vector256<ulong> right) { throw new NotImplementedException(); }
+ public static Vector256<ulong> CompareEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareEqual(left, right);
/// <summary>
/// __m256i _mm256_cmpgt_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right) => CompareGreaterThan(left, right);
/// <summary>
/// __m256i _mm256_cmpgt_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right) => CompareGreaterThan(left, right);
/// <summary>
/// __m256i _mm256_cmpgt_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right) => CompareGreaterThan(left, right);
/// <summary>
/// __m256i _mm256_cmpgt_epi64 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right) { throw new NotImplementedException(); }
+ public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right) => CompareGreaterThan(left, right);
/// <summary>
/// __m256i _mm256_cvtepi8_epi16 (__m128i a)
/// </summary>
- public static Vector256<short> ConvertToVector256Short(Vector128<sbyte> value) { throw new NotImplementedException(); }
+ public static Vector256<short> ConvertToVector256Short(Vector128<sbyte> value) => ConvertToVector256Short(value);
/// <summary>
/// __m256i _mm256_cvtepu8_epi16 (__m128i a)
/// </summary>
- public static Vector256<ushort> ConvertToVector256UShort(Vector128<byte> value) { throw new NotImplementedException(); }
+ public static Vector256<ushort> ConvertToVector256UShort(Vector128<byte> value) => ConvertToVector256UShort(value);
/// <summary>
/// __m256i _mm256_cvtepi8_epi32 (__m128i a)
/// </summary>
- public static Vector256<int> ConvertToVector256Int(Vector128<sbyte> value) { throw new NotImplementedException(); }
+ public static Vector256<int> ConvertToVector256Int(Vector128<sbyte> value) => ConvertToVector256Int(value);
/// <summary>
/// __m256i _mm256_cvtepi16_epi32 (__m128i a)
/// </summary>
- public static Vector256<int> ConvertToVector256Int(Vector128<short> value) { throw new NotImplementedException(); }
+ public static Vector256<int> ConvertToVector256Int(Vector128<short> value) => ConvertToVector256Int(value);
/// <summary>
/// __m256i _mm256_cvtepu8_epi32 (__m128i a)
/// </summary>
- public static Vector256<uint> ConvertToVector256UInt(Vector128<byte> value) { throw new NotImplementedException(); }
+ public static Vector256<uint> ConvertToVector256UInt(Vector128<byte> value) => ConvertToVector256UInt(value);
/// <summary>
/// __m256i _mm256_cvtepu16_epi32 (__m128i a)
/// </summary>
- public static Vector256<uint> ConvertToVector256UInt(Vector128<ushort> value) { throw new NotImplementedException(); }
+ public static Vector256<uint> ConvertToVector256UInt(Vector128<ushort> value) => ConvertToVector256UInt(value);
/// <summary>
/// __m256i _mm256_cvtepi8_epi64 (__m128i a)
/// </summary>
- public static Vector256<long> ConvertToVector256Long(Vector128<sbyte> value) { throw new NotImplementedException(); }
+ public static Vector256<long> ConvertToVector256Long(Vector128<sbyte> value) => ConvertToVector256Long(value);
/// <summary>
/// __m256i _mm256_cvtepi16_epi64 (__m128i a)
/// </summary>
- public static Vector256<long> ConvertToVector256Long(Vector128<short> value) { throw new NotImplementedException(); }
+ public static Vector256<long> ConvertToVector256Long(Vector128<short> value) => ConvertToVector256Long(value);
/// <summary>
/// __m256i _mm256_cvtepi32_epi64 (__m128i a)
/// </summary>
- public static Vector256<long> ConvertToVector256Long(Vector128<int> value) { throw new NotImplementedException(); }
+ public static Vector256<long> ConvertToVector256Long(Vector128<int> value) => ConvertToVector256Long(value);
/// <summary>
/// __m256i _mm256_cvtepu8_epi64 (__m128i a)
/// </summary>
- public static Vector256<ulong> ConvertToVector256ULong(Vector128<byte> value) { throw new NotImplementedException(); }
+ public static Vector256<ulong> ConvertToVector256ULong(Vector128<byte> value) => ConvertToVector256ULong(value);
/// <summary>
/// __m256i _mm256_cvtepu16_epi64 (__m128i a)
/// </summary>
- public static Vector256<ulong> ConvertToVector256ULong(Vector128<ushort> value) { throw new NotImplementedException(); }
+ public static Vector256<ulong> ConvertToVector256ULong(Vector128<ushort> value) => ConvertToVector256ULong(value);
/// <summary>
/// __m256i _mm256_cvtepu32_epi64 (__m128i a)
/// </summary>
- public static Vector256<ulong> ConvertToVector256ULong(Vector128<uint> value) { throw new NotImplementedException(); }
+ public static Vector256<ulong> ConvertToVector256ULong(Vector128<uint> value) => ConvertToVector256ULong(value);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) => ExtractVector128(value, index);
// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(sbyte* address, Vector256<sbyte> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(sbyte* address, Vector256<sbyte> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) { throw new NotImplementedException(); }
+ public static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) => ExtractVector128(value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(byte* address, Vector256<byte> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(byte* address, Vector256<byte> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static Vector128<short> ExtractVector128(Vector256<short> value, byte index) { throw new NotImplementedException(); }
+ public static Vector128<short> ExtractVector128(Vector256<short> value, byte index) => ExtractVector128(value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(short* address, Vector256<short> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(short* address, Vector256<short> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) { throw new NotImplementedException(); }
+ public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) => ExtractVector128(value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(ushort* address, Vector256<ushort> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(ushort* address, Vector256<ushort> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static Vector128<int> ExtractVector128(Vector256<int> value, byte index) { throw new NotImplementedException(); }
+ public static Vector128<int> ExtractVector128(Vector256<int> value, byte index) => ExtractVector128(value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(int* address, Vector256<int> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(int* address, Vector256<int> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) { throw new NotImplementedException(); }
+ public static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) => ExtractVector128(value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(uint* address, Vector256<uint> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(uint* address, Vector256<uint> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static Vector128<long> ExtractVector128(Vector256<long> value, byte index) { throw new NotImplementedException(); }
+ public static Vector128<long> ExtractVector128(Vector256<long> value, byte index) => ExtractVector128(value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(long* address, Vector256<long> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(long* address, Vector256<long> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) { throw new NotImplementedException(); }
+ public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) => ExtractVector128(value, index);
/// <summary>
/// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
/// </summary>
- public static unsafe void ExtractVector128(ulong* address, Vector256<ulong> value, byte index) { throw new NotImplementedException(); }
+ public static unsafe void ExtractVector128(ulong* address, Vector256<ulong> value, byte index) => ExtractVector128(address, value, index);
/// <summary>
/// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<int> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<int> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<int> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<int> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<int> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<int> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<int> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<int> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m128 _mm_i32gather_ps (float const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<int> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<int> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m128d _mm_i32gather_pd (double const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<int> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<int> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<long> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<long> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<long> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<long> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<long> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<long> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<long> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<long> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m128 _mm_i64gather_ps (float const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<long> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<long> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m128d _mm_i64gather_pd (double const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<long> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<long> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
/// </summary>
- public static unsafe Vector256<int> GatherVector256(int* baseAddress, Vector256<int> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<int> GatherVector256(int* baseAddress, Vector256<int> index, byte scale) => GatherVector256(baseAddress, index, scale);
/// <summary>
/// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
/// </summary>
- public static unsafe Vector256<uint> GatherVector256(uint* baseAddress, Vector256<int> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<uint> GatherVector256(uint* baseAddress, Vector256<int> index, byte scale) => GatherVector256(baseAddress, index, scale);
/// <summary>
/// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector128<int> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector128<int> index, byte scale) => GatherVector256(baseAddress, index, scale);
/// <summary>
/// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector128<int> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector128<int> index, byte scale) => GatherVector256(baseAddress, index, scale);
/// <summary>
/// __m256 _mm256_i32gather_ps (float const* base_addr, __m256i vindex, const int scale)
/// </summary>
- public static unsafe Vector256<float> GatherVector256(float* baseAddress, Vector256<int> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<float> GatherVector256(float* baseAddress, Vector256<int> index, byte scale) => GatherVector256(baseAddress, index, scale);
/// <summary>
/// __m256d _mm256_i32gather_pd (double const* base_addr, __m128i vindex, const int scale)
/// </summary>
- public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector128<int> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector128<int> index, byte scale) => GatherVector256(baseAddress, index, scale);
/// <summary>
/// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector256<long> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector256<long> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector256<long> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector256<long> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale)
/// </summary>
- public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector256<long> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector256<long> index, byte scale) => GatherVector256(baseAddress, index, scale);
/// <summary>
/// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale)
/// </summary>
- public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector256<long> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector256<long> index, byte scale) => GatherVector256(baseAddress, index, scale);
/// <summary>
/// __m128 _mm256_i64gather_ps (float const* base_addr, __m256i vindex, const int scale)
/// </summary>
- public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector256<long> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector256<long> index, byte scale) => GatherVector128(baseAddress, index, scale);
/// <summary>
/// __m256d _mm256_i64gather_pd (double const* base_addr, __m256i vindex, const int scale)
/// </summary>
- public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector256<long> index, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector256<long> index, byte scale) => GatherVector256(baseAddress, index, scale);
/// <summary>
/// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
/// </summary>
- public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<int> index, Vector128<int> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<int> index, Vector128<int> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
/// </summary>
- public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<int> index, Vector128<uint> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<int> index, Vector128<uint> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
/// </summary>
- public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<int> index, Vector128<long> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<int> index, Vector128<long> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
/// </summary>
- public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<int> index, Vector128<ulong> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<int> index, Vector128<ulong> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128 _mm_mask_i32gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale)
/// </summary>
- public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<int> index, Vector128<float> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<int> index, Vector128<float> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128d _mm_mask_i32gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale)
/// </summary>
- public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<int> index, Vector128<double> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<int> index, Vector128<double> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
/// </summary>
- public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<long> index, Vector128<int> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<long> index, Vector128<int> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
/// </summary>
- public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<long> index, Vector128<uint> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<long> index, Vector128<uint> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
/// </summary>
- public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<long> index, Vector128<long> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<long> index, Vector128<long> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
/// </summary>
- public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<long> index, Vector128<ulong> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<long> index, Vector128<ulong> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128 _mm_mask_i64gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale)
/// </summary>
- public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<long> index, Vector128<float> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<long> index, Vector128<float> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128d _mm_mask_i64gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale)
/// </summary>
- public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<long> index, Vector128<double> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<long> index, Vector128<double> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale)
/// </summary>
- public static unsafe Vector256<int> GatherMaskVector256(Vector256<int> source, int* baseAddress, Vector256<int> index, Vector256<int> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<int> GatherMaskVector256(Vector256<int> source, int* baseAddress, Vector256<int> index, Vector256<int> mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale);
/// <summary>
/// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale)
/// </summary>
- public static unsafe Vector256<uint> GatherMaskVector256(Vector256<uint> source, uint* baseAddress, Vector256<int> index, Vector256<uint> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<uint> GatherMaskVector256(Vector256<uint> source, uint* baseAddress, Vector256<int> index, Vector256<uint> mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale);
/// <summary>
/// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale)
/// </summary>
- public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector128<int> index, Vector256<long> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector128<int> index, Vector256<long> mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale);
/// <summary>
/// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale)
/// </summary>
- public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector128<int> index, Vector256<ulong> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector128<int> index, Vector256<ulong> mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale);
/// <summary>
/// __m256 _mm256_mask_i32gather_ps (__m256 src, float const* base_addr, __m256i vindex, __m256 mask, const int scale)
/// </summary>
- public static unsafe Vector256<float> GatherMaskVector256(Vector256<float> source, float* baseAddress, Vector256<int> index, Vector256<float> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<float> GatherMaskVector256(Vector256<float> source, float* baseAddress, Vector256<int> index, Vector256<float> mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale);
/// <summary>
/// __m256d _mm256_mask_i32gather_pd (__m256d src, double const* base_addr, __m128i vindex, __m256d mask, const int scale)
/// </summary>
- public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector128<int> index, Vector256<double> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector128<int> index, Vector256<double> mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale)
/// </summary>
- public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector256<long> index, Vector128<int> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector256<long> index, Vector128<int> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale)
/// </summary>
- public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector256<long> index, Vector128<uint> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector256<long> index, Vector128<uint> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale)
/// </summary>
- public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector256<long> index, Vector256<long> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector256<long> index, Vector256<long> mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale);
/// <summary>
/// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale)
/// </summary>
- public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector256<long> index, Vector256<ulong> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector256<long> index, Vector256<ulong> mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale);
/// <summary>
/// __m128 _mm256_mask_i64gather_ps (__m128 src, float const* base_addr, __m256i vindex, __m128 mask, const int scale)
/// </summary>
- public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector256<long> index, Vector128<float> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector256<long> index, Vector128<float> mask, byte scale) => GatherMaskVector128(source, baseAddress, index, mask, scale);
/// <summary>
/// __m256d _mm256_mask_i64gather_pd (__m256d src, double const* base_addr, __m256i vindex, __m256d mask, const int scale)
/// </summary>
- public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector256<long> index, Vector256<double> mask, byte scale) { throw new NotImplementedException(); }
+ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector256<long> index, Vector256<double> mask, byte scale) => GatherMaskVector256(source, baseAddress, index, mask, scale);
/// <summary>
/// __m256i _mm256_hadd_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> HorizontalAdd(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> HorizontalAdd(Vector256<short> left, Vector256<short> right) => HorizontalAdd(left, right);
/// <summary>
/// __m256i _mm256_hadd_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> HorizontalAdd(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> HorizontalAdd(Vector256<int> left, Vector256<int> right) => HorizontalAdd(left, right);
/// <summary>
/// __m256i _mm256_hadds_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> HorizontalAddSaturate(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> HorizontalAddSaturate(Vector256<short> left, Vector256<short> right) => HorizontalAddSaturate(left, right);
/// <summary>
/// __m256i _mm256_hsub_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> HorizontalSubtract(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> HorizontalSubtract(Vector256<short> left, Vector256<short> right) => HorizontalSubtract(left, right);
/// <summary>
/// __m256i _mm256_hsub_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> HorizontalSubtract(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> HorizontalSubtract(Vector256<int> left, Vector256<int> right) => HorizontalSubtract(left, right);
/// <summary>
/// __m256i _mm256_hsubs_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> HorizontalSubtractSaturate(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> HorizontalSubtractSaturate(Vector256<short> left, Vector256<short> right) => HorizontalSubtractSaturate(left, right);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static Vector256<sbyte> Insert(Vector256<sbyte> value, Vector128<sbyte> data, byte index) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> Insert(Vector256<sbyte> value, Vector128<sbyte> data, byte index) => Insert(value, data, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static unsafe Vector256<sbyte> Insert(Vector256<sbyte> value, sbyte* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<sbyte> Insert(Vector256<sbyte> value, sbyte* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static Vector256<byte> Insert(Vector256<byte> value, Vector128<byte> data, byte index) { throw new NotImplementedException(); }
+ public static Vector256<byte> Insert(Vector256<byte> value, Vector128<byte> data, byte index) => Insert(value, data, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static unsafe Vector256<byte> Insert(Vector256<byte> value, byte* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<byte> Insert(Vector256<byte> value, byte* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static Vector256<short> Insert(Vector256<short> value, Vector128<short> data, byte index) { throw new NotImplementedException(); }
+ public static Vector256<short> Insert(Vector256<short> value, Vector128<short> data, byte index) => Insert(value, data, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static unsafe Vector256<short> Insert(Vector256<short> value, short* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<short> Insert(Vector256<short> value, short* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static Vector256<ushort> Insert(Vector256<ushort> value, Vector128<ushort> data, byte index) { throw new NotImplementedException(); }
+ public static Vector256<ushort> Insert(Vector256<ushort> value, Vector128<ushort> data, byte index) => Insert(value, data, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static unsafe Vector256<ushort> Insert(Vector256<ushort> value, ushort* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ushort> Insert(Vector256<ushort> value, ushort* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static Vector256<int> Insert(Vector256<int> value, Vector128<int> data, byte index) { throw new NotImplementedException(); }
+ public static Vector256<int> Insert(Vector256<int> value, Vector128<int> data, byte index) => Insert(value, data, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static unsafe Vector256<int> Insert(Vector256<int> value, int* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<int> Insert(Vector256<int> value, int* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static Vector256<uint> Insert(Vector256<uint> value, Vector128<uint> data, byte index) { throw new NotImplementedException(); }
+ public static Vector256<uint> Insert(Vector256<uint> value, Vector128<uint> data, byte index) => Insert(value, data, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static unsafe Vector256<uint> Insert(Vector256<uint> value, uint* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<uint> Insert(Vector256<uint> value, uint* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static Vector256<long> Insert(Vector256<long> value, Vector128<long> data, byte index) { throw new NotImplementedException(); }
+ public static Vector256<long> Insert(Vector256<long> value, Vector128<long> data, byte index) => Insert(value, data, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static unsafe Vector256<long> Insert(Vector256<long> value, long* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<long> Insert(Vector256<long> value, long* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static Vector256<ulong> Insert(Vector256<ulong> value, Vector128<ulong> data, byte index) { throw new NotImplementedException(); }
+ public static Vector256<ulong> Insert(Vector256<ulong> value, Vector128<ulong> data, byte index) => Insert(value, data, index);
/// <summary>
/// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
/// </summary>
- public static unsafe Vector256<ulong> Insert(Vector256<ulong> value, ulong* address, byte index) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ulong> Insert(Vector256<ulong> value, ulong* address, byte index) => Insert(value, address, index);
/// <summary>
/// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask)
/// </summary>
- public static unsafe Vector128<int> MaskLoad(int* address, Vector128<int> mask) { throw new NotImplementedException(); }
+ public static unsafe Vector128<int> MaskLoad(int* address, Vector128<int> mask) => MaskLoad(address, mask);
/// <summary>
/// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask)
/// </summary>
- public static unsafe Vector128<uint> MaskLoad(uint* address, Vector128<uint> mask) { throw new NotImplementedException(); }
+ public static unsafe Vector128<uint> MaskLoad(uint* address, Vector128<uint> mask) => MaskLoad(address, mask);
/// <summary>
/// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask)
/// </summary>
- public static unsafe Vector128<long> MaskLoad(long* address, Vector128<long> mask) { throw new NotImplementedException(); }
+ public static unsafe Vector128<long> MaskLoad(long* address, Vector128<long> mask) => MaskLoad(address, mask);
/// <summary>
/// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask)
/// </summary>
- public static unsafe Vector128<ulong> MaskLoad(ulong* address, Vector128<ulong> mask) { throw new NotImplementedException(); }
+ public static unsafe Vector128<ulong> MaskLoad(ulong* address, Vector128<ulong> mask) => MaskLoad(address, mask);
/// <summary>
/// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask)
/// </summary>
- public static unsafe Vector256<int> MaskLoad(int* address, Vector256<int> mask) { throw new NotImplementedException(); }
+ public static unsafe Vector256<int> MaskLoad(int* address, Vector256<int> mask) => MaskLoad(address, mask);
/// <summary>
/// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask)
/// </summary>
- public static unsafe Vector256<uint> MaskLoad(uint* address, Vector256<uint> mask) { throw new NotImplementedException(); }
+ public static unsafe Vector256<uint> MaskLoad(uint* address, Vector256<uint> mask) => MaskLoad(address, mask);
/// <summary>
/// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask)
/// </summary>
- public static unsafe Vector256<long> MaskLoad(long* address, Vector256<long> mask) { throw new NotImplementedException(); }
+ public static unsafe Vector256<long> MaskLoad(long* address, Vector256<long> mask) => MaskLoad(address, mask);
/// <summary>
/// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask)
/// </summary>
- public static unsafe Vector256<ulong> MaskLoad(ulong* address, Vector256<ulong> mask) { throw new NotImplementedException(); }
+ public static unsafe Vector256<ulong> MaskLoad(ulong* address, Vector256<ulong> mask) => MaskLoad(address, mask);
/// <summary>
/// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a)
/// </summary>
- public static unsafe void MaskStore(int* address, Vector128<int> mask, Vector128<int> source) { throw new NotImplementedException(); }
+ public static unsafe void MaskStore(int* address, Vector128<int> mask, Vector128<int> source) => MaskStore(address, mask, source);
/// <summary>
/// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a)
/// </summary>
- public static unsafe void MaskStore(uint* address, Vector128<uint> mask, Vector128<uint> source) { throw new NotImplementedException(); }
+ public static unsafe void MaskStore(uint* address, Vector128<uint> mask, Vector128<uint> source) => MaskStore(address, mask, source);
/// <summary>
/// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a)
/// </summary>
- public static unsafe void MaskStore(long* address, Vector128<long> mask, Vector128<long> source) { throw new NotImplementedException(); }
+ public static unsafe void MaskStore(long* address, Vector128<long> mask, Vector128<long> source) => MaskStore(address, mask, source);
/// <summary>
/// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a)
/// </summary>
- public static unsafe void MaskStore(ulong* address, Vector128<ulong> mask, Vector128<ulong> source) { throw new NotImplementedException(); }
+ public static unsafe void MaskStore(ulong* address, Vector128<ulong> mask, Vector128<ulong> source) => MaskStore(address, mask, source);
/// <summary>
/// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a)
/// </summary>
- public static unsafe void MaskStore(int* address, Vector256<int> mask, Vector256<int> source) { throw new NotImplementedException(); }
+ public static unsafe void MaskStore(int* address, Vector256<int> mask, Vector256<int> source) => MaskStore(address, mask, source);
/// <summary>
/// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a)
/// </summary>
- public static unsafe void MaskStore(uint* address, Vector256<uint> mask, Vector256<uint> source) { throw new NotImplementedException(); }
+ public static unsafe void MaskStore(uint* address, Vector256<uint> mask, Vector256<uint> source) => MaskStore(address, mask, source);
/// <summary>
/// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a)
/// </summary>
- public static unsafe void MaskStore(long* address, Vector256<long> mask, Vector256<long> source) { throw new NotImplementedException(); }
+ public static unsafe void MaskStore(long* address, Vector256<long> mask, Vector256<long> source) => MaskStore(address, mask, source);
/// <summary>
/// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a)
/// </summary>
- public static unsafe void MaskStore(ulong* address, Vector256<ulong> mask, Vector256<ulong> source) { throw new NotImplementedException(); }
+ public static unsafe void MaskStore(ulong* address, Vector256<ulong> mask, Vector256<ulong> source) => MaskStore(address, mask, source);
/// <summary>
/// __m256i _mm256_madd_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> MultiplyAddAdjacent(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<int> MultiplyAddAdjacent(Vector256<short> left, Vector256<short> right) => MultiplyAddAdjacent(left, right);
/// <summary>
/// __m256i _mm256_maddubs_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> MultiplyAddAdjacent(Vector256<byte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<short> MultiplyAddAdjacent(Vector256<byte> left, Vector256<sbyte> right) => MultiplyAddAdjacent(left, right);
/// <summary>
/// __m256i _mm256_max_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> Max(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> Max(Vector256<sbyte> left, Vector256<sbyte> right) => Max(left, right);
/// <summary>
/// __m256i _mm256_max_epu8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> Max(Vector256<byte> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> Max(Vector256<byte> left, Vector256<short> right) => Max(left, right);
/// <summary>
/// __m256i _mm256_max_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> Max(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> Max(Vector256<short> left, Vector256<short> right) => Max(left, right);
/// <summary>
/// __m256i _mm256_max_epu16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> Max(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> Max(Vector256<ushort> left, Vector256<ushort> right) => Max(left, right);
/// <summary>
/// __m256i _mm256_max_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> Max(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> Max(Vector256<int> left, Vector256<int> right) => Max(left, right);
/// <summary>
/// __m256i _mm256_max_epu32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<uint> Max(Vector256<uint> left, Vector256<uint> right) { throw new NotImplementedException(); }
+ public static Vector256<uint> Max(Vector256<uint> left, Vector256<uint> right) => Max(left, right);
/// <summary>
/// __m256i _mm256_min_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> Min(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> Min(Vector256<sbyte> left, Vector256<sbyte> right) => Min(left, right);
/// <summary>
/// __m256i _mm256_min_epu8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> Min(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> Min(Vector256<byte> left, Vector256<byte> right) => Min(left, right);
/// <summary>
/// __m256i _mm256_min_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> Min(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> Min(Vector256<short> left, Vector256<short> right) => Min(left, right);
/// <summary>
/// __m256i _mm256_min_epu16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> Min(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> Min(Vector256<ushort> left, Vector256<ushort> right) => Min(left, right);
/// <summary>
/// __m256i _mm256_min_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> Min(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> Min(Vector256<int> left, Vector256<int> right) => Min(left, right);
/// <summary>
/// __m256i _mm256_min_epu32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<uint> Min(Vector256<uint> left, Vector256<uint> right) { throw new NotImplementedException(); }
+ public static Vector256<uint> Min(Vector256<uint> left, Vector256<uint> right) => Min(left, right);
/// <summary>
/// int _mm256_movemask_epi8 (__m256i a)
/// </summary>
- public static int MoveMask(Vector256<sbyte> value) { throw new NotImplementedException(); }
+ public static int MoveMask(Vector256<sbyte> value) => MoveMask(value);
/// <summary>
/// int _mm256_movemask_epi8 (__m256i a)
/// </summary>
- public static int MoveMask(Vector256<byte> value) { throw new NotImplementedException(); }
+ public static int MoveMask(Vector256<byte> value) => MoveMask(value);
/// <summary>
/// __m256i _mm256_mpsadbw_epu8 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<ushort> MultipleSumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right, byte mask) { throw new NotImplementedException(); }
+ public static Vector256<ushort> MultipleSumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right, byte mask) => MultipleSumAbsoluteDifferences(left, right, mask);
/// <summary>
/// __m256i _mm256_mul_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<long> Multiply(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<long> Multiply(Vector256<int> left, Vector256<int> right) => Multiply(left, right);
/// <summary>
/// __m256i _mm256_mul_epu32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ulong> Multiply(Vector256<uint> left, Vector256<uint> right) { throw new NotImplementedException(); }
+ public static Vector256<ulong> Multiply(Vector256<uint> left, Vector256<uint> right) => Multiply(left, right);
/// <summary>
/// __m256i _mm256_mulhi_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> MultiplyHigh(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> MultiplyHigh(Vector256<short> left, Vector256<short> right) => MultiplyHigh(left, right);
/// <summary>
/// __m256i _mm256_mulhi_epu16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> MultiplyHigh(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> MultiplyHigh(Vector256<ushort> left, Vector256<ushort> right) => MultiplyHigh(left, right);
/// <summary>
/// __m256i _mm256_mulhrs_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> MultiplyHighRoundScale(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> MultiplyHighRoundScale(Vector256<short> left, Vector256<short> right) => MultiplyHighRoundScale(left, right);
/// <summary>
/// __m256i _mm256_mullo_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> MultiplyLow(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> MultiplyLow(Vector256<short> left, Vector256<short> right) => MultiplyLow(left, right);
/// <summary>
/// __m256i _mm256_mullo_epu16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> MultiplyLow(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> MultiplyLow(Vector256<int> left, Vector256<int> right) => MultiplyLow(left, right);
/// <summary>
/// __m256i _mm256_or_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> Or(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> Or(Vector256<sbyte> left, Vector256<sbyte> right) => Or(left, right);
/// <summary>
/// __m256i _mm256_or_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> Or(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> Or(Vector256<byte> left, Vector256<byte> right) => Or(left, right);
/// <summary>
/// __m256i _mm256_or_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> Or(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> Or(Vector256<short> left, Vector256<short> right) => Or(left, right);
/// <summary>
/// __m256i _mm256_or_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> Or(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> Or(Vector256<ushort> left, Vector256<ushort> right) => Or(left, right);
/// <summary>
/// __m256i _mm256_or_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> Or(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> Or(Vector256<int> left, Vector256<int> right) => Or(left, right);
/// <summary>
/// __m256i _mm256_or_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<uint> Or(Vector256<uint> left, Vector256<uint> right) { throw new NotImplementedException(); }
+ public static Vector256<uint> Or(Vector256<uint> left, Vector256<uint> right) => Or(left, right);
/// <summary>
/// __m256i _mm256_or_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<long> Or(Vector256<long> left, Vector256<long> right) { throw new NotImplementedException(); }
+ public static Vector256<long> Or(Vector256<long> left, Vector256<long> right) => Or(left, right);
/// <summary>
/// __m256i _mm256_or_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ulong> Or(Vector256<ulong> left, Vector256<ulong> right) { throw new NotImplementedException(); }
+ public static Vector256<ulong> Or(Vector256<ulong> left, Vector256<ulong> right) => Or(left, right);
/// <summary>
/// __m256i _mm256_packs_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> PackSignedSaturate(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> PackSignedSaturate(Vector256<short> left, Vector256<short> right) => PackSignedSaturate(left, right);
/// <summary>
/// __m256i _mm256_packs_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> PackSignedSaturate(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<short> PackSignedSaturate(Vector256<int> left, Vector256<int> right) => PackSignedSaturate(left, right);
/// <summary>
/// __m256i _mm256_packus_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> PackUnsignedSaturate(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> PackUnsignedSaturate(Vector256<short> left, Vector256<short> right) => PackUnsignedSaturate(left, right);
/// <summary>
/// __m256i _mm256_packus_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> PackUnsignedSaturate(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> PackUnsignedSaturate(Vector256<int> left, Vector256<int> right) => PackUnsignedSaturate(left, right);
/// <summary>
/// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) => Permute2x128(left, right, control);
/// <summary>
/// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) => Permute2x128(left, right, control);
/// <summary>
/// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) => Permute2x128(left, right, control);
/// <summary>
/// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) => Permute2x128(left, right, control);
/// <summary>
/// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) => Permute2x128(left, right, control);
/// <summary>
/// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) => Permute2x128(left, right, control);
/// <summary>
/// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) => Permute2x128(left, right, control);
/// <summary>
/// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
/// </summary>
- public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) { throw new NotImplementedException(); }
+ public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) => Permute2x128(left, right, control);
/// <summary>
/// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<long> Permute4x64(Vector256<long> value, byte control) { throw new NotImplementedException(); }
+ public static Vector256<long> Permute4x64(Vector256<long> value, byte control) => Permute4x64(value, control);
/// <summary>
/// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<ulong> Permute4x64(Vector256<ulong> value, byte control) { throw new NotImplementedException(); }
+ public static Vector256<ulong> Permute4x64(Vector256<ulong> value, byte control) => Permute4x64(value, control);
/// <summary>
/// __m256d _mm256_permute4x64_pd (__m256d a, const int imm8)
/// </summary>
- public static Vector256<double> Permute4x64(Vector256<double> value, byte control) { throw new NotImplementedException(); }
+ public static Vector256<double> Permute4x64(Vector256<double> value, byte control) => Permute4x64(value, control);
/// <summary>
/// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx)
/// </summary>
- public static Vector256<int> PermuteVar8x32(Vector256<int> left, Vector256<int> mask) { throw new NotImplementedException(); }
+ public static Vector256<int> PermuteVar8x32(Vector256<int> left, Vector256<int> mask) => PermuteVar8x32(left, mask);
/// <summary>
/// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx)
/// </summary>
- public static Vector256<uint> PermuteVar8x32(Vector256<uint> left, Vector256<uint> mask) { throw new NotImplementedException(); }
+ public static Vector256<uint> PermuteVar8x32(Vector256<uint> left, Vector256<uint> mask) => PermuteVar8x32(left, mask);
/// <summary>
/// __m256 _mm256_permutevar8x32_ps (__m256 a, __m256i idx)
/// </summary>
- public static Vector256<float> PermuteVar8x32(Vector256<float> left, Vector256<float> mask) { throw new NotImplementedException(); }
+ public static Vector256<float> PermuteVar8x32(Vector256<float> left, Vector256<float> mask) => PermuteVar8x32(left, mask);
/// <summary>
/// __m256i _mm256_slli_epi16 (__m256i a, int imm8)
/// </summary>
- public static Vector256<short> ShiftLeftLogical(Vector256<short> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<short> ShiftLeftLogical(Vector256<short> value, byte count) => ShiftLeftLogical(value, count);
/// <summary>
/// __m256i _mm256_slli_epi16 (__m256i a, int imm8)
/// </summary>
- public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, byte count) => ShiftLeftLogical(value, count);
/// <summary>
/// __m256i _mm256_slli_epi32 (__m256i a, int imm8)
/// </summary>
- public static Vector256<int> ShiftLeftLogical(Vector256<int> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<int> ShiftLeftLogical(Vector256<int> value, byte count) => ShiftLeftLogical(value, count);
/// <summary>
/// __m256i _mm256_slli_epi32 (__m256i a, int imm8)
/// </summary>
- public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, byte count) => ShiftLeftLogical(value, count);
/// <summary>
/// __m256i _mm256_slli_epi64 (__m256i a, int imm8)
/// </summary>
- public static Vector256<long> ShiftLeftLogical(Vector256<long> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<long> ShiftLeftLogical(Vector256<long> value, byte count) => ShiftLeftLogical(value, count);
/// <summary>
/// __m256i _mm256_slli_epi64 (__m256i a, int imm8)
/// </summary>
- public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, byte count) => ShiftLeftLogical(value, count);
/// <summary>
/// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<sbyte> ShiftLeftLogical128BitLane(Vector256<sbyte> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> ShiftLeftLogical128BitLane(Vector256<sbyte> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<byte> ShiftLeftLogical128BitLane(Vector256<byte> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<byte> ShiftLeftLogical128BitLane(Vector256<byte> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<short> ShiftLeftLogical128BitLane(Vector256<short> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<short> ShiftLeftLogical128BitLane(Vector256<short> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<ushort> ShiftLeftLogical128BitLane(Vector256<ushort> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<ushort> ShiftLeftLogical128BitLane(Vector256<ushort> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<int> ShiftLeftLogical128BitLane(Vector256<int> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<int> ShiftLeftLogical128BitLane(Vector256<int> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<uint> ShiftLeftLogical128BitLane(Vector256<uint> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<uint> ShiftLeftLogical128BitLane(Vector256<uint> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<long> ShiftLeftLogical128BitLane(Vector256<long> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<long> ShiftLeftLogical128BitLane(Vector256<long> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<ulong> ShiftLeftLogical128BitLane(Vector256<ulong> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<ulong> ShiftLeftLogical128BitLane(Vector256<ulong> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count)
/// </summary>
- public static Vector256<int> ShiftLeftLogicalVariable(Vector256<int> value, Vector256<uint> count) { throw new NotImplementedException(); }
+ public static Vector256<int> ShiftLeftLogicalVariable(Vector256<int> value, Vector256<uint> count) => ShiftLeftLogicalVariable(value, count);
/// <summary>
/// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count)
/// </summary>
- public static Vector256<uint> ShiftLeftLogicalVariable(Vector256<uint> value, Vector256<uint> count) { throw new NotImplementedException(); }
+ public static Vector256<uint> ShiftLeftLogicalVariable(Vector256<uint> value, Vector256<uint> count) => ShiftLeftLogicalVariable(value, count);
/// <summary>
/// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count)
/// </summary>
- public static Vector256<long> ShiftLeftLogicalVariable(Vector256<long> value, Vector256<ulong> count) { throw new NotImplementedException(); }
+ public static Vector256<long> ShiftLeftLogicalVariable(Vector256<long> value, Vector256<ulong> count) => ShiftLeftLogicalVariable(value, count);
/// <summary>
/// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count)
/// </summary>
- public static Vector256<ulong> ShiftLeftLogicalVariable(Vector256<ulong> value, Vector256<ulong> count) { throw new NotImplementedException(); }
+ public static Vector256<ulong> ShiftLeftLogicalVariable(Vector256<ulong> value, Vector256<ulong> count) => ShiftLeftLogicalVariable(value, count);
/// <summary>
/// __m256i _mm256_srai_epi16 (__m256i a, int imm8)
/// </summary>
- public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, byte count) => ShiftRightArithmetic(value, count);
/// <summary>
/// __m256i _mm256_srai_epi32 (__m256i a, int imm8)
/// </summary>
- public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, byte count) => ShiftRightArithmetic(value, count);
/// <summary>
/// __m256i _mm256_srav_epi32 (__m256i a, __m256i count)
/// </summary>
- public static Vector256<int> ShiftRightArithmeticVariable(Vector256<int> value, Vector256<uint> count) { throw new NotImplementedException(); }
+ public static Vector256<int> ShiftRightArithmeticVariable(Vector256<int> value, Vector256<uint> count) => ShiftRightArithmeticVariable(value, count);
/// <summary>
/// __m256i _mm256_srli_epi16 (__m256i a, int imm8)
/// </summary>
- public static Vector256<short> ShiftRightLogical(Vector256<short> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<short> ShiftRightLogical(Vector256<short> value, byte count) => ShiftRightLogical(value, count);
/// <summary>
/// __m256i _mm256_srli_epi16 (__m256i a, int imm8)
/// </summary>
- public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, byte count) => ShiftRightLogical(value, count);
/// <summary>
/// __m256i _mm256_srli_epi32 (__m256i a, int imm8)
/// </summary>
- public static Vector256<int> ShiftRightLogical(Vector256<int> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<int> ShiftRightLogical(Vector256<int> value, byte count) => ShiftRightLogical(value, count);
/// <summary>
/// __m256i _mm256_srli_epi32 (__m256i a, int imm8)
/// </summary>
- public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, byte count) => ShiftRightLogical(value, count);
/// <summary>
/// __m256i _mm256_srli_epi64 (__m256i a, int imm8)
/// </summary>
- public static Vector256<long> ShiftRightLogical(Vector256<long> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<long> ShiftRightLogical(Vector256<long> value, byte count) => ShiftRightLogical(value, count);
/// <summary>
/// __m256i _mm256_srli_epi64 (__m256i a, int imm8)
/// </summary>
- public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, byte count) { throw new NotImplementedException(); }
+ public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, byte count) => ShiftRightLogical(value, count);
/// <summary>
/// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<sbyte> ShiftRightLogical128BitLane(Vector256<sbyte> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> ShiftRightLogical128BitLane(Vector256<sbyte> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<byte> ShiftRightLogical128BitLane(Vector256<byte> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<byte> ShiftRightLogical128BitLane(Vector256<byte> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<short> ShiftRightLogical128BitLane(Vector256<short> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<short> ShiftRightLogical128BitLane(Vector256<short> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<ushort> ShiftRightLogical128BitLane(Vector256<ushort> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<ushort> ShiftRightLogical128BitLane(Vector256<ushort> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<int> ShiftRightLogical128BitLane(Vector256<int> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<int> ShiftRightLogical128BitLane(Vector256<int> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<uint> ShiftRightLogical128BitLane(Vector256<uint> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<uint> ShiftRightLogical128BitLane(Vector256<uint> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<long> ShiftRightLogical128BitLane(Vector256<long> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<long> ShiftRightLogical128BitLane(Vector256<long> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<ulong> ShiftRightLogical128BitLane(Vector256<ulong> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector256<ulong> ShiftRightLogical128BitLane(Vector256<ulong> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count)
/// </summary>
- public static Vector256<int> ShiftRightLogicalVariable(Vector256<int> value, Vector256<uint> count) { throw new NotImplementedException(); }
+ public static Vector256<int> ShiftRightLogicalVariable(Vector256<int> value, Vector256<uint> count) => ShiftRightLogicalVariable(value, count);
/// <summary>
/// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count)
/// </summary>
- public static Vector256<uint> ShiftRightLogicalVariable(Vector256<uint> value, Vector256<uint> count) { throw new NotImplementedException(); }
+ public static Vector256<uint> ShiftRightLogicalVariable(Vector256<uint> value, Vector256<uint> count) => ShiftRightLogicalVariable(value, count);
/// <summary>
/// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count)
/// </summary>
- public static Vector256<long> ShiftRightLogicalVariable(Vector256<long> value, Vector256<ulong> count) { throw new NotImplementedException(); }
+ public static Vector256<long> ShiftRightLogicalVariable(Vector256<long> value, Vector256<ulong> count) => ShiftRightLogicalVariable(value, count);
/// <summary>
/// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count)
/// </summary>
- public static Vector256<ulong> ShiftRightLogicalVariable(Vector256<ulong> value, Vector256<ulong> count) { throw new NotImplementedException(); }
+ public static Vector256<ulong> ShiftRightLogicalVariable(Vector256<ulong> value, Vector256<ulong> count) => ShiftRightLogicalVariable(value, count);
/// <summary>
/// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> Shuffle(Vector256<sbyte> value, Vector256<sbyte> mask) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> Shuffle(Vector256<sbyte> value, Vector256<sbyte> mask) => Shuffle(value, mask);
/// <summary>
/// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> Shuffle(Vector256<byte> value, Vector256<byte> mask) { throw new NotImplementedException(); }
+ public static Vector256<byte> Shuffle(Vector256<byte> value, Vector256<byte> mask) => Shuffle(value, mask);
/// <summary>
/// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<int> Shuffle(Vector256<int> value, byte control) { throw new NotImplementedException(); }
+ public static Vector256<int> Shuffle(Vector256<int> value, byte control) => Shuffle(value, control);
/// <summary>
/// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<uint> Shuffle(Vector256<uint> value, byte control) { throw new NotImplementedException(); }
+ public static Vector256<uint> Shuffle(Vector256<uint> value, byte control) => Shuffle(value, control);
/// <summary>
/// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<short> ShuffleHigh(Vector256<short> value, byte control) { throw new NotImplementedException(); }
+ public static Vector256<short> ShuffleHigh(Vector256<short> value, byte control) => ShuffleHigh(value, control);
/// <summary>
/// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<ushort> ShuffleHigh(Vector256<ushort> value, byte control) { throw new NotImplementedException(); }
+ public static Vector256<ushort> ShuffleHigh(Vector256<ushort> value, byte control) => ShuffleHigh(value, control);
/// <summary>
/// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<short> ShuffleLow(Vector256<short> value, byte control) { throw new NotImplementedException(); }
+ public static Vector256<short> ShuffleLow(Vector256<short> value, byte control) => ShuffleLow(value, control);
/// <summary>
/// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8)
/// </summary>
- public static Vector256<ushort> ShuffleLow(Vector256<ushort> value, byte control) { throw new NotImplementedException(); }
+ public static Vector256<ushort> ShuffleLow(Vector256<ushort> value, byte control) => ShuffleLow(value, control);
/// <summary>
/// __m256i _mm256_sign_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> Sign(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> Sign(Vector256<sbyte> left, Vector256<sbyte> right) => Sign(left, right);
/// <summary>
/// __m256i _mm256_sign_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> Sign(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> Sign(Vector256<short> left, Vector256<short> right) => Sign(left, right);
/// <summary>
/// __m256i _mm256_sign_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> Sign(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> Sign(Vector256<int> left, Vector256<int> right) => Sign(left, right);
/// <summary>
/// __m256i _mm256_sub_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> Subtract(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> Subtract(Vector256<sbyte> left, Vector256<sbyte> right) => Subtract(left, right);
/// <summary>
/// __m256i _mm256_sub_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> Subtract(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> Subtract(Vector256<byte> left, Vector256<byte> right) => Subtract(left, right);
/// <summary>
/// __m256i _mm256_sub_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> Subtract(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> Subtract(Vector256<short> left, Vector256<short> right) => Subtract(left, right);
/// <summary>
/// __m256i _mm256_sub_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> Subtract(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> Subtract(Vector256<ushort> left, Vector256<ushort> right) => Subtract(left, right);
/// <summary>
/// __m256i _mm256_sub_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right) => Subtract(left, right);
/// <summary>
/// __m256i _mm256_sub_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right) { throw new NotImplementedException(); }
+ public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right) => Subtract(left, right);
/// <summary>
/// __m256i _mm256_sub_epi64 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<long> Subtract(Vector256<long> left, Vector256<long> right) { throw new NotImplementedException(); }
+ public static Vector256<long> Subtract(Vector256<long> left, Vector256<long> right) => Subtract(left, right);
/// <summary>
/// __m256i _mm256_sub_epi64 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ulong> Subtract(Vector256<ulong> left, Vector256<ulong> right) { throw new NotImplementedException(); }
+ public static Vector256<ulong> Subtract(Vector256<ulong> left, Vector256<ulong> right) => Subtract(left, right);
/// <summary>
/// __m256i _mm256_subs_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> SubtractSaturate(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> SubtractSaturate(Vector256<sbyte> left, Vector256<sbyte> right) => SubtractSaturate(left, right);
/// <summary>
/// __m256i _mm256_subs_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> SubtractSaturate(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> SubtractSaturate(Vector256<short> left, Vector256<short> right) => SubtractSaturate(left, right);
/// <summary>
/// __m256i _mm256_subs_epu8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> SubtractSaturate(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> SubtractSaturate(Vector256<byte> left, Vector256<byte> right) => SubtractSaturate(left, right);
/// <summary>
/// __m256i _mm256_subs_epu16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> SubtractSaturate(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> SubtractSaturate(Vector256<ushort> left, Vector256<ushort> right) => SubtractSaturate(left, right);
/// <summary>
/// __m256i _mm256_sad_epu8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ulong> SumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<ulong> SumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right) => SumAbsoluteDifferences(left, right);
/// <summary>
/// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> UnpackHigh(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> UnpackHigh(Vector256<sbyte> left, Vector256<sbyte> right) => UnpackHigh(left, right);
/// <summary>
/// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> UnpackHigh(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> UnpackHigh(Vector256<byte> left, Vector256<byte> right) => UnpackHigh(left, right);
/// <summary>
/// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> UnpackHigh(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> UnpackHigh(Vector256<short> left, Vector256<short> right) => UnpackHigh(left, right);
/// <summary>
/// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> UnpackHigh(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> UnpackHigh(Vector256<ushort> left, Vector256<ushort> right) => UnpackHigh(left, right);
/// <summary>
/// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> UnpackHigh(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> UnpackHigh(Vector256<int> left, Vector256<int> right) => UnpackHigh(left, right);
/// <summary>
/// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<uint> UnpackHigh(Vector256<uint> left, Vector256<uint> right) { throw new NotImplementedException(); }
+ public static Vector256<uint> UnpackHigh(Vector256<uint> left, Vector256<uint> right) => UnpackHigh(left, right);
/// <summary>
/// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<long> UnpackHigh(Vector256<long> left, Vector256<long> right) { throw new NotImplementedException(); }
+ public static Vector256<long> UnpackHigh(Vector256<long> left, Vector256<long> right) => UnpackHigh(left, right);
/// <summary>
/// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ulong> UnpackHigh(Vector256<ulong> left, Vector256<ulong> right) { throw new NotImplementedException(); }
+ public static Vector256<ulong> UnpackHigh(Vector256<ulong> left, Vector256<ulong> right) => UnpackHigh(left, right);
/// <summary>
/// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> UnpackLow(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> UnpackLow(Vector256<sbyte> left, Vector256<sbyte> right) => UnpackLow(left, right);
/// <summary>
/// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> UnpackLow(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> UnpackLow(Vector256<byte> left, Vector256<byte> right) => UnpackLow(left, right);
/// <summary>
/// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> UnpackLow(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> UnpackLow(Vector256<short> left, Vector256<short> right) => UnpackLow(left, right);
/// <summary>
/// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> UnpackLow(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> UnpackLow(Vector256<ushort> left, Vector256<ushort> right) => UnpackLow(left, right);
/// <summary>
/// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> UnpackLow(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> UnpackLow(Vector256<int> left, Vector256<int> right) => UnpackLow(left, right);
/// <summary>
/// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<uint> UnpackLow(Vector256<uint> left, Vector256<uint> right) { throw new NotImplementedException(); }
+ public static Vector256<uint> UnpackLow(Vector256<uint> left, Vector256<uint> right) => UnpackLow(left, right);
/// <summary>
/// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<long> UnpackLow(Vector256<long> left, Vector256<long> right) { throw new NotImplementedException(); }
+ public static Vector256<long> UnpackLow(Vector256<long> left, Vector256<long> right) => UnpackLow(left, right);
/// <summary>
/// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ulong> UnpackLow(Vector256<ulong> left, Vector256<ulong> right) { throw new NotImplementedException(); }
+ public static Vector256<ulong> UnpackLow(Vector256<ulong> left, Vector256<ulong> right) => UnpackLow(left, right);
/// <summary>
/// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<sbyte> Xor(Vector256<sbyte> left, Vector256<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector256<sbyte> Xor(Vector256<sbyte> left, Vector256<sbyte> right) => Xor(left, right);
/// <summary>
/// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<byte> Xor(Vector256<byte> left, Vector256<byte> right) { throw new NotImplementedException(); }
+ public static Vector256<byte> Xor(Vector256<byte> left, Vector256<byte> right) => Xor(left, right);
/// <summary>
/// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<short> Xor(Vector256<short> left, Vector256<short> right) { throw new NotImplementedException(); }
+ public static Vector256<short> Xor(Vector256<short> left, Vector256<short> right) => Xor(left, right);
/// <summary>
/// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ushort> Xor(Vector256<ushort> left, Vector256<ushort> right) { throw new NotImplementedException(); }
+ public static Vector256<ushort> Xor(Vector256<ushort> left, Vector256<ushort> right) => Xor(left, right);
/// <summary>
/// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<int> Xor(Vector256<int> left, Vector256<int> right) { throw new NotImplementedException(); }
+ public static Vector256<int> Xor(Vector256<int> left, Vector256<int> right) => Xor(left, right);
/// <summary>
/// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<uint> Xor(Vector256<uint> left, Vector256<uint> right) { throw new NotImplementedException(); }
+ public static Vector256<uint> Xor(Vector256<uint> left, Vector256<uint> right) => Xor(left, right);
/// <summary>
/// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<long> Xor(Vector256<long> left, Vector256<long> right) { throw new NotImplementedException(); }
+ public static Vector256<long> Xor(Vector256<long> left, Vector256<long> right) => Xor(left, right);
/// <summary>
/// __m256i _mm256_xor_si256 (__m256i a, __m256i b)
/// </summary>
- public static Vector256<ulong> Xor(Vector256<ulong> left, Vector256<ulong> right) { throw new NotImplementedException(); }
+ public static Vector256<ulong> Xor(Vector256<ulong> left, Vector256<ulong> right) => Xor(left, right);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel BMI1 hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Bmi1
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// unsigned int _andn_u32 (unsigned int a, unsigned int b)
+ /// </summary>
+ public static uint AndNot(uint left, uint right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned __int64 _andn_u64 (unsigned __int64 a, unsigned __int64 b)
+ /// </summary>
+ public static ulong AndNot(ulong left, ulong right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// unsigned int _bextr_u32 (unsigned int a, unsigned int start, unsigned int len)
+ /// </summary>
+ public static uint BitFieldExtract(uint value, uint start, uint length) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned __int64 _bextr_u64 (unsigned __int64 a, unsigned int start, unsigned int len)
+ /// </summary>
+ public static ulong BitFieldExtract(ulong value, ulong start, ulong length) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned int _bextr2_u32 (unsigned int a, unsigned int control)
+ /// </summary>
+ public static uint BitFieldExtract(uint value, uint control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned __int64 _bextr2_u64 (unsigned __int64 a, unsigned __int64 control)
+ /// </summary>
+ public static ulong BitFieldExtract(ulong value, ulong control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// unsigned int _blsi_u32 (unsigned int a)
+ /// </summary>
+ public static uint ExtractLowestSetBit(uint value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned __int64 _blsi_u64 (unsigned __int64 a)
+ /// </summary>
+ public static ulong ExtractLowestSetBit(ulong value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// unsigned int _blsmsk_u32 (unsigned int a)
+ /// </summary>
+ public static uint GetMaskUptoLowestSetBit(uint value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned __int64 _blsmsk_u64 (unsigned __int64 a)
+ /// </summary>
+ public static ulong GetMaskUptoLowestSetBit(ulong value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// unsigned int _blsr_u32 (unsigned int a)
+ /// </summary>
+ public static uint ResetLowestSetBit(uint value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned __int64 _blsr_u64 (unsigned __int64 a)
+ /// </summary>
+ public static ulong ResetLowestSetBit(ulong value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_tzcnt_32 (unsigned int a)
+ /// </summary>
+ public static uint TrailingZeroCount(uint value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __int64 _mm_tzcnt_64 (unsigned __int64 a)
+ /// </summary>
+ public static ulong TrailingZeroCount(ulong value) { throw new PlatformNotSupportedException(); }
+ }
+}
[CLSCompliant(false)]
public static class Bmi1
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// unsigned int _andn_u32 (unsigned int a, unsigned int b)
/// </summary>
- public static uint AndNot(uint left, uint right) { throw new NotImplementedException(); }
+ public static uint AndNot(uint left, uint right) => AndNot(left, right);
/// <summary>
/// unsigned __int64 _andn_u64 (unsigned __int64 a, unsigned __int64 b)
/// </summary>
- public static ulong AndNot(ulong left, ulong right) { throw new NotImplementedException(); }
+ public static ulong AndNot(ulong left, ulong right) => AndNot(left, right);
/// <summary>
/// unsigned int _bextr_u32 (unsigned int a, unsigned int start, unsigned int len)
/// </summary>
- public static uint BitFieldExtract(uint value, uint start, uint length) { throw new NotImplementedException(); }
+ public static uint BitFieldExtract(uint value, uint start, uint length) => BitFieldExtract(value, start, length);
/// <summary>
/// unsigned __int64 _bextr_u64 (unsigned __int64 a, unsigned int start, unsigned int len)
/// </summary>
- public static ulong BitFieldExtract(ulong value, ulong start, ulong length) { throw new NotImplementedException(); }
+ public static ulong BitFieldExtract(ulong value, ulong start, ulong length) => BitFieldExtract(value, start, length);
/// <summary>
/// unsigned int _bextr2_u32 (unsigned int a, unsigned int control)
/// </summary>
- public static uint BitFieldExtract(uint value, uint control) { throw new NotImplementedException(); }
+ public static uint BitFieldExtract(uint value, uint control) => BitFieldExtract(value, control);
/// <summary>
/// unsigned __int64 _bextr2_u64 (unsigned __int64 a, unsigned __int64 control)
/// </summary>
- public static ulong BitFieldExtract(ulong value, ulong control) { throw new NotImplementedException(); }
+ public static ulong BitFieldExtract(ulong value, ulong control) => BitFieldExtract(value, control);
/// <summary>
/// unsigned int _blsi_u32 (unsigned int a)
/// </summary>
- public static uint ExtractLowestSetBit(uint value) { throw new NotImplementedException(); }
+ public static uint ExtractLowestSetBit(uint value) => ExtractLowestSetBit(value);
/// <summary>
/// unsigned __int64 _blsi_u64 (unsigned __int64 a)
/// </summary>
- public static ulong ExtractLowestSetBit(ulong value) { throw new NotImplementedException(); }
+ public static ulong ExtractLowestSetBit(ulong value) => ExtractLowestSetBit(value);
/// <summary>
/// unsigned int _blsmsk_u32 (unsigned int a)
/// </summary>
- public static uint GetMaskUptoLowestSetBit(uint value) { throw new NotImplementedException(); }
+ public static uint GetMaskUptoLowestSetBit(uint value) => GetMaskUptoLowestSetBit(value);
/// <summary>
/// unsigned __int64 _blsmsk_u64 (unsigned __int64 a)
/// </summary>
- public static ulong GetMaskUptoLowestSetBit(ulong value) { throw new NotImplementedException(); }
+ public static ulong GetMaskUptoLowestSetBit(ulong value) => GetMaskUptoLowestSetBit(value);
/// <summary>
/// unsigned int _blsr_u32 (unsigned int a)
/// </summary>
- public static uint ResetLowestSetBit(uint value) { throw new NotImplementedException(); }
+ public static uint ResetLowestSetBit(uint value) => ResetLowestSetBit(value);
/// <summary>
/// unsigned __int64 _blsr_u64 (unsigned __int64 a)
/// </summary>
- public static ulong ResetLowestSetBit(ulong value) { throw new NotImplementedException(); }
+ public static ulong ResetLowestSetBit(ulong value) => ResetLowestSetBit(value);
/// <summary>
/// int _mm_tzcnt_32 (unsigned int a)
/// </summary>
- public static uint TrailingZeroCount(uint value) { throw new NotImplementedException(); }
+ public static uint TrailingZeroCount(uint value) => TrailingZeroCount(value);
/// <summary>
/// __int64 _mm_tzcnt_64 (unsigned __int64 a)
/// </summary>
- public static ulong TrailingZeroCount(ulong value) { throw new NotImplementedException(); }
+ public static ulong TrailingZeroCount(ulong value) => TrailingZeroCount(value);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel BMI2 hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Bmi2
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// unsigned int _bzhi_u32 (unsigned int a, unsigned int index)
+ /// </summary>
+ public static uint ZeroHighBits(uint value, uint index) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned __int64 _bzhi_u64 (unsigned __int64 a, unsigned int index)
+ /// </summary>
+ public static ulong ZeroHighBits(ulong value, ulong index) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi)
+ /// </summary>
+ public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* high) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi)
+ /// </summary>
+ public static unsafe ulong MultiplyNoFlags(ulong left, ulong right, ulong* high) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// unsigned int _pdep_u32 (unsigned int a, unsigned int mask)
+ /// </summary>
+ public static uint ParallelBitDeposit(uint value, uint mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned __int64 _pdep_u64 (unsigned __int64 a, unsigned __int64 mask)
+ /// </summary>
+ public static ulong ParallelBitDeposit(ulong value, ulong mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// unsigned int _pext_u32 (unsigned int a, unsigned int mask)
+ /// </summary>
+ public static uint ParallelBitExtract(uint value, uint mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned __int64 _pext_u64 (unsigned __int64 a, unsigned __int64 mask)
+ /// </summary>
+ public static ulong ParallelBitExtract(ulong value, ulong mask) { throw new PlatformNotSupportedException(); }
+ }
+}
[CLSCompliant(false)]
public static class Bmi2
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// unsigned int _bzhi_u32 (unsigned int a, unsigned int index)
/// </summary>
- public static uint ZeroHighBits(uint value, uint index) { throw new NotImplementedException(); }
+ public static uint ZeroHighBits(uint value, uint index) => ZeroHighBits(value, index);
/// <summary>
/// unsigned __int64 _bzhi_u64 (unsigned __int64 a, unsigned int index)
/// </summary>
- public static ulong ZeroHighBits(ulong value, ulong index) { throw new NotImplementedException(); }
+ public static ulong ZeroHighBits(ulong value, ulong index) => ZeroHighBits(value, index);
/// <summary>
/// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi)
/// </summary>
- public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* high) { throw new NotImplementedException(); }
+ public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* high) => MultiplyNoFlags(left, right, high);
/// <summary>
/// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi)
/// </summary>
- public static unsafe ulong MultiplyNoFlags(ulong left, ulong right, ulong* high) { throw new NotImplementedException(); }
+ public static unsafe ulong MultiplyNoFlags(ulong left, ulong right, ulong* high) => MultiplyNoFlags(left, right, high);
/// <summary>
/// unsigned int _pdep_u32 (unsigned int a, unsigned int mask)
/// </summary>
- public static uint ParallelBitDeposit(uint value, uint mask) { throw new NotImplementedException(); }
+ public static uint ParallelBitDeposit(uint value, uint mask) => ParallelBitDeposit(value, mask);
/// <summary>
/// unsigned __int64 _pdep_u64 (unsigned __int64 a, unsigned __int64 mask)
/// </summary>
- public static ulong ParallelBitDeposit(ulong value, ulong mask) { throw new NotImplementedException(); }
+ public static ulong ParallelBitDeposit(ulong value, ulong mask) => ParallelBitDeposit(value, mask);
/// <summary>
/// unsigned int _pext_u32 (unsigned int a, unsigned int mask)
/// </summary>
- public static uint ParallelBitExtract(uint value, uint mask) { throw new NotImplementedException(); }
+ public static uint ParallelBitExtract(uint value, uint mask) => ParallelBitExtract(value, mask);
/// <summary>
/// unsigned __int64 _pext_u64 (unsigned __int64 a, unsigned __int64 mask)
/// </summary>
- public static ulong ParallelBitExtract(ulong value, ulong mask) { throw new NotImplementedException(); }
+ public static ulong ParallelBitExtract(ulong value, ulong mask) => ParallelBitExtract(value, mask);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel FMA hardware instructions via intrinsics
+ /// </summary>
+ public static class Fma
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c)
+ /// </summary>
+ public static Vector128<float> MultiplyAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_fmadd_pd (__m128d a, __m128d b, __m128d c)
+ /// </summary>
+ public static Vector128<double> MultiplyAdd(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_fmadd_ps (__m256 a, __m256 b, __m256 c)
+ /// </summary>
+ public static Vector256<float> MultiplyAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_fmadd_pd (__m256d a, __m256d b, __m256d c)
+ /// </summary>
+ public static Vector256<double> MultiplyAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_fmaddsub_ps (__m128 a, __m128 b, __m128 c)
+ /// </summary>
+ public static Vector128<float> MultiplyAddSubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_fmaddsub_pd (__m128d a, __m128d b, __m128d c)
+ /// </summary>
+ public static Vector128<double> MultiplyAddSubtract(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_fmaddsub_ps (__m256 a, __m256 b, __m256 c)
+ /// </summary>
+ public static Vector256<float> MultiplyAddSubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_fmaddsub_pd (__m256d a, __m256d b, __m256d c)
+ /// </summary>
+ public static Vector256<double> MultiplyAddSubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_fmsub_ps (__m128 a, __m128 b, __m128 c)
+ /// </summary>
+ public static Vector128<float> MultiplySubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_fmsub_pd (__m128d a, __m128d b, __m128d c)
+ /// </summary>
+ public static Vector128<double> MultiplySubtract(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_fmsub_ps (__m256 a, __m256 b, __m256 c)
+ /// </summary>
+ public static Vector256<float> MultiplySubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_fmsub_pd (__m256d a, __m256d b, __m256d c)
+ /// </summary>
+ public static Vector256<double> MultiplySubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_fmsubadd_ps (__m128 a, __m128 b, __m128 c)
+ /// </summary>
+ public static Vector128<float> MultiplySubtractAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_fmsubadd_pd (__m128d a, __m128d b, __m128d c)
+ /// </summary>
+ public static Vector128<double> MultiplySubtractAdd(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_fmsubadd_ps (__m256 a, __m256 b, __m256 c)
+ /// </summary>
+ public static Vector256<float> MultiplySubtractAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_fmsubadd_pd (__m256d a, __m256d b, __m256d c)
+ /// </summary>
+ public static Vector256<double> MultiplySubtractAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_fnmadd_ps (__m128 a, __m128 b, __m128 c)
+ /// </summary>
+ public static Vector128<float> MultiplyAddNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_fnmadd_pd (__m128d a, __m128d b, __m128d c)
+ /// </summary>
+ public static Vector128<double> MultiplyAddNegated(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_fnmadd_ps (__m256 a, __m256 b, __m256 c)
+ /// </summary>
+ public static Vector256<float> MultiplyAddNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_fnmadd_pd (__m256d a, __m256d b, __m256d c)
+ /// </summary>
+ public static Vector256<double> MultiplyAddNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_fnmsub_ps (__m128 a, __m128 b, __m128 c)
+ /// </summary>
+ public static Vector128<float> MultiplySubtractNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_fnmsub_pd (__m128d a, __m128d b, __m128d c)
+ /// </summary>
+ public static Vector128<double> MultiplySubtractNegated(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256 _mm256_fnmsub_ps (__m256 a, __m256 b, __m256 c)
+ /// </summary>
+ public static Vector256<float> MultiplySubtractNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m256d _mm256_fnmsub_pd (__m256d a, __m256d b, __m256d c)
+ /// </summary>
+ public static Vector256<double> MultiplySubtractNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new PlatformNotSupportedException(); }
+ }
+}
/// </summary>
public static class Fma
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c)
/// </summary>
- public static Vector128<float> MultiplyAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new NotImplementedException(); }
+ public static Vector128<float> MultiplyAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplyAdd(a, b, c);
/// <summary>
/// __m128d _mm_fmadd_pd (__m128d a, __m128d b, __m128d c)
/// </summary>
- public static Vector128<double> MultiplyAdd(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new NotImplementedException(); }
+ public static Vector128<double> MultiplyAdd(Vector128<double> a, Vector128<double> b, Vector128<double> c) => MultiplyAdd(a, b, c);
/// <summary>
/// __m256 _mm256_fmadd_ps (__m256 a, __m256 b, __m256 c)
/// </summary>
- public static Vector256<float> MultiplyAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw new NotImplementedException(); }
+ public static Vector256<float> MultiplyAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c) => MultiplyAdd(a, b, c);
/// <summary>
/// __m256d _mm256_fmadd_pd (__m256d a, __m256d b, __m256d c)
/// </summary>
- public static Vector256<double> MultiplyAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new NotImplementedException(); }
+ public static Vector256<double> MultiplyAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplyAdd(a, b, c);
/// <summary>
/// __m128 _mm_fmaddsub_ps (__m128 a, __m128 b, __m128 c)
/// </summary>
- public static Vector128<float> MultiplyAddSubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new NotImplementedException(); }
+ public static Vector128<float> MultiplyAddSubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplyAddSubtract(a, b, c);
/// <summary>
/// __m128d _mm_fmaddsub_pd (__m128d a, __m128d b, __m128d c)
/// </summary>
- public static Vector128<double> MultiplyAddSubtract(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new NotImplementedException(); }
+ public static Vector128<double> MultiplyAddSubtract(Vector128<double> a, Vector128<double> b, Vector128<double> c) => MultiplyAddSubtract(a, b, c);
/// <summary>
/// __m256 _mm256_fmaddsub_ps (__m256 a, __m256 b, __m256 c)
/// </summary>
- public static Vector256<float> MultiplyAddSubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw new NotImplementedException(); }
+ public static Vector256<float> MultiplyAddSubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c) => MultiplyAddSubtract(a, b, c);
/// <summary>
/// __m256d _mm256_fmaddsub_pd (__m256d a, __m256d b, __m256d c)
/// </summary>
- public static Vector256<double> MultiplyAddSubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new NotImplementedException(); }
+ public static Vector256<double> MultiplyAddSubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplyAddSubtract(a, b, c);
/// <summary>
/// __m128 _mm_fmsub_ps (__m128 a, __m128 b, __m128 c)
/// </summary>
- public static Vector128<float> MultiplySubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new NotImplementedException(); }
+ public static Vector128<float> MultiplySubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplySubtract(a, b, c);
/// <summary>
/// __m128d _mm_fmsub_pd (__m128d a, __m128d b, __m128d c)
/// </summary>
- public static Vector128<double> MultiplySubtract(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new NotImplementedException(); }
+ public static Vector128<double> MultiplySubtract(Vector128<double> a, Vector128<double> b, Vector128<double> c) => MultiplySubtract(a, b, c);
/// <summary>
/// __m256 _mm256_fmsub_ps (__m256 a, __m256 b, __m256 c)
/// </summary>
- public static Vector256<float> MultiplySubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw new NotImplementedException(); }
+ public static Vector256<float> MultiplySubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c) => MultiplySubtract(a, b, c);
/// <summary>
/// __m256d _mm256_fmsub_pd (__m256d a, __m256d b, __m256d c)
/// </summary>
- public static Vector256<double> MultiplySubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new NotImplementedException(); }
+ public static Vector256<double> MultiplySubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplySubtract(a, b, c);
/// <summary>
/// __m128 _mm_fmsubadd_ps (__m128 a, __m128 b, __m128 c)
/// </summary>
- public static Vector128<float> MultiplySubtractAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new NotImplementedException(); }
+ public static Vector128<float> MultiplySubtractAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplySubtractAdd(a, b, c);
/// <summary>
/// __m128d _mm_fmsubadd_pd (__m128d a, __m128d b, __m128d c)
/// </summary>
- public static Vector128<double> MultiplySubtractAdd(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new NotImplementedException(); }
+ public static Vector128<double> MultiplySubtractAdd(Vector128<double> a, Vector128<double> b, Vector128<double> c) => MultiplySubtractAdd(a, b, c);
/// <summary>
/// __m256 _mm256_fmsubadd_ps (__m256 a, __m256 b, __m256 c)
/// </summary>
- public static Vector256<float> MultiplySubtractAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw new NotImplementedException(); }
+ public static Vector256<float> MultiplySubtractAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c) => MultiplySubtractAdd(a, b, c);
/// <summary>
/// __m256d _mm256_fmsubadd_pd (__m256d a, __m256d b, __m256d c)
/// </summary>
- public static Vector256<double> MultiplySubtractAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new NotImplementedException(); }
+ public static Vector256<double> MultiplySubtractAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplySubtractAdd(a, b, c);
/// <summary>
/// __m128 _mm_fnmadd_ps (__m128 a, __m128 b, __m128 c)
/// </summary>
- public static Vector128<float> MultiplyAddNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new NotImplementedException(); }
+ public static Vector128<float> MultiplyAddNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplyAddNegated(a, b, c);
/// <summary>
/// __m128d _mm_fnmadd_pd (__m128d a, __m128d b, __m128d c)
/// </summary>
- public static Vector128<double> MultiplyAddNegated(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new NotImplementedException(); }
+ public static Vector128<double> MultiplyAddNegated(Vector128<double> a, Vector128<double> b, Vector128<double> c) => MultiplyAddNegated(a, b, c);
/// <summary>
/// __m256 _mm256_fnmadd_ps (__m256 a, __m256 b, __m256 c)
/// </summary>
- public static Vector256<float> MultiplyAddNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw new NotImplementedException(); }
+ public static Vector256<float> MultiplyAddNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c) => MultiplyAddNegated(a, b, c);
/// <summary>
/// __m256d _mm256_fnmadd_pd (__m256d a, __m256d b, __m256d c)
/// </summary>
- public static Vector256<double> MultiplyAddNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new NotImplementedException(); }
+ public static Vector256<double> MultiplyAddNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplyAddNegated(a, b, c);
/// <summary>
/// __m128 _mm_fnmsub_ps (__m128 a, __m128 b, __m128 c)
/// </summary>
- public static Vector128<float> MultiplySubtractNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw new NotImplementedException(); }
+ public static Vector128<float> MultiplySubtractNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c) => MultiplySubtractNegated(a, b, c);
/// <summary>
/// __m128d _mm_fnmsub_pd (__m128d a, __m128d b, __m128d c)
/// </summary>
- public static Vector128<double> MultiplySubtractNegated(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw new NotImplementedException(); }
+ public static Vector128<double> MultiplySubtractNegated(Vector128<double> a, Vector128<double> b, Vector128<double> c) => MultiplySubtractNegated(a, b, c);
/// <summary>
/// __m256 _mm256_fnmsub_ps (__m256 a, __m256 b, __m256 c)
/// </summary>
- public static Vector256<float> MultiplySubtractNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw new NotImplementedException(); }
+ public static Vector256<float> MultiplySubtractNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c) => MultiplySubtractNegated(a, b, c);
/// <summary>
/// __m256d _mm256_fnmsub_pd (__m256d a, __m256d b, __m256d c)
/// </summary>
- public static Vector256<double> MultiplySubtractNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw new NotImplementedException(); }
+ public static Vector256<double> MultiplySubtractNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplySubtractNegated(a, b, c);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel LZCNT hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Lzcnt
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// unsigned int _lzcnt_u32 (unsigned int a)
+ /// </summary>
+ public static uint LeadingZeroCount(uint value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned __int64 _lzcnt_u64 (unsigned __int64 a)
+ /// </summary>
+ public static ulong LeadingZeroCount(ulong value) { throw new PlatformNotSupportedException(); }
+ }
+}
// See the LICENSE file in the project root for more information.
using System;
-using System.Runtime.Intrinsics;
namespace System.Runtime.Intrinsics.X86
{
[CLSCompliant(false)]
public static class Lzcnt
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// unsigned int _lzcnt_u32 (unsigned int a)
/// </summary>
- public static uint LeadingZeroCount(uint value) { throw new NotImplementedException(); }
+ public static uint LeadingZeroCount(uint value) => LeadingZeroCount(value);
/// <summary>
/// unsigned __int64 _lzcnt_u64 (unsigned __int64 a)
/// </summary>
- public static ulong LeadingZeroCount(ulong value) { throw new NotImplementedException(); }
+ public static ulong LeadingZeroCount(ulong value) => LeadingZeroCount(value);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel PCLMULQDQ hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Pclmulqdq
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<long> CarryLessMultiply(Vector128<long> left, Vector128<long> right, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<ulong> CarryLessMultiply(Vector128<ulong> left, Vector128<ulong> right, byte control) { throw new PlatformNotSupportedException(); }
+ }
+}
[CLSCompliant(false)]
public static class Pclmulqdq
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<long> CarryLessMultiply(Vector128<long> left, Vector128<long> right, byte control) { throw new NotImplementedException(); }
+ public static Vector128<long> CarryLessMultiply(Vector128<long> left, Vector128<long> right, byte control) => CarryLessMultiply(left, right, control);
/// <summary>
/// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<ulong> CarryLessMultiply(Vector128<ulong> left, Vector128<ulong> right, byte control) { throw new NotImplementedException(); }
+ public static Vector128<ulong> CarryLessMultiply(Vector128<ulong> left, Vector128<ulong> right, byte control) => CarryLessMultiply(left, right, control);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel POPCNT hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Popcnt
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// int _mm_popcnt_u32 (unsigned int a)
+ /// </summary>
+ public static int PopCount(uint value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __int64 _mm_popcnt_u64 (unsigned __int64 a)
+ /// </summary>
+ public static long PopCount(ulong value) { throw new PlatformNotSupportedException(); }
+ }
+}
// See the LICENSE file in the project root for more information.
using System;
-using System.Runtime.Intrinsics;
namespace System.Runtime.Intrinsics.X86
{
[CLSCompliant(false)]
public static class Popcnt
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// int _mm_popcnt_u32 (unsigned int a)
/// </summary>
- public static int PopCount(uint value) { throw new NotImplementedException(); }
+ public static int PopCount(uint value) => PopCount(value);
/// <summary>
/// __int64 _mm_popcnt_u64 (unsigned __int64 a)
/// </summary>
- public static long PopCount(ulong value) { throw new NotImplementedException(); }
+ public static long PopCount(ulong value) => PopCount(value);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel SSE hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Sse
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// __m128 _mm_add_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> Add(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_and_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> And(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_andnot_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> AndNot(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmpeq_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> CompareEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmpgt_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> CompareGreaterThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmpge_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmplt_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> CompareLessThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmple_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmpneq_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> CompareNotEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmpngt_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> CompareNotGreaterThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmpnge_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> CompareNotGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmpnlt_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> CompareNotLessThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmpnle_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> CompareNotLessThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmpord_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> CompareOrdered(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_cmpunord_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> CompareUnordered(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_div_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_loadu_ps (float const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<float> Load(float* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_load_ps (float const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<float> LoadAligned(float* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_max_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> Max(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_min_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> Min(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_movehl_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> MoveHighToLow(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_movelh_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> MoveLowToHigh(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_mul_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_or_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> Or(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_rcp_ps (__m128 a)
+ /// </summary>
+ public static Vector128<float> Reciprocal(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_rsqrt_ps (__m128 a)
+ /// </summary>
+ public static Vector128<float> ReciprocalSquareRoot(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_set_ps (float e3, float e2, float e1, float e0)
+ /// </summary>
+ public static Vector128<float> Set(float e3, float e2, float e1, float e0) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_set1_ps (float a)
+ /// </summary>
+ public static Vector128<float> Set1(float value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_setzero_ps (void)
+ /// </summary>
+ public static Vector128<float> SetZero() { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_castpd_ps (__m128d a)
+ /// __m128i _mm_castpd_si128 (__m128d a)
+ /// __m128d _mm_castps_pd (__m128 a)
+ /// __m128i _mm_castps_si128 (__m128 a)
+ /// __m128d _mm_castsi128_pd (__m128i a)
+ /// __m128 _mm_castsi128_ps (__m128i a)
+ /// </summary>
+ public static Vector128<U> StaticCast<T, U>(Vector128<T> value) where T : struct where U : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_shuffle_ps (__m128 a, __m128 b, unsigned int control)
+ /// </summary>
+ public static Vector128<float> Shuffle(Vector128<float> left, Vector128<float> right, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_sqrt_ps (__m128 a)
+ /// </summary>
+ public static Vector128<float> Sqrt(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm_store_ps (float* mem_addr, __m128 a)
+ /// </summary>
+ public static unsafe void StoreAligned(float* address, Vector128<float> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm_stream_ps (float* mem_addr, __m128 a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(float* address, Vector128<float> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm_storeu_ps (float* mem_addr, __m128 a)
+ /// </summary>
+ public static unsafe void Store(float* address, Vector128<float> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_sub_ps (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_unpackhi_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> UnpackHigh(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_unpacklo_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> UnpackLow(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_xor_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> Xor(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+ }
+}
[CLSCompliant(false)]
public static class Sse
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// __m128 _mm_add_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> Add(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> Add(Vector128<float> left, Vector128<float> right) => Add(left, right);
/// <summary>
/// __m128 _mm_and_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> And(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> And(Vector128<float> left, Vector128<float> right) => And(left, right);
/// <summary>
/// __m128 _mm_andnot_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> AndNot(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> AndNot(Vector128<float> left, Vector128<float> right) => AndNot(left, right);
/// <summary>
/// __m128 _mm_cmpeq_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> CompareEqual(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> CompareEqual(Vector128<float> left, Vector128<float> right) => CompareEqual(left, right);
/// <summary>
/// __m128 _mm_cmpgt_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> CompareGreaterThan(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> CompareGreaterThan(Vector128<float> left, Vector128<float> right) => CompareGreaterThan(left, right);
/// <summary>
/// __m128 _mm_cmpge_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrEqual(left, right);
/// <summary>
/// __m128 _mm_cmplt_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> CompareLessThan(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> CompareLessThan(Vector128<float> left, Vector128<float> right) => CompareLessThan(left, right);
/// <summary>
/// __m128 _mm_cmple_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareLessThanOrEqual(left, right);
/// <summary>
/// __m128 _mm_cmpneq_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> CompareNotEqual(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> CompareNotEqual(Vector128<float> left, Vector128<float> right) => CompareNotEqual(left, right);
/// <summary>
/// __m128 _mm_cmpngt_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> CompareNotGreaterThan(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> CompareNotGreaterThan(Vector128<float> left, Vector128<float> right) => CompareNotGreaterThan(left, right);
/// <summary>
/// __m128 _mm_cmpnge_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> CompareNotGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> CompareNotGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareNotGreaterThanOrEqual(left, right);
/// <summary>
/// __m128 _mm_cmpnlt_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> CompareNotLessThan(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> CompareNotLessThan(Vector128<float> left, Vector128<float> right) => CompareNotLessThan(left, right);
/// <summary>
/// __m128 _mm_cmpnle_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> CompareNotLessThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> CompareNotLessThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareNotLessThanOrEqual(left, right);
/// <summary>
/// __m128 _mm_cmpord_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> CompareOrdered(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> CompareOrdered(Vector128<float> left, Vector128<float> right) => CompareOrdered(left, right);
/// <summary>
/// __m128 _mm_cmpunord_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> CompareUnordered(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> CompareUnordered(Vector128<float> left, Vector128<float> right) => CompareUnordered(left, right);
/// <summary>
/// __m128 _mm_div_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right) => Divide(left, right);
/// <summary>
/// __m128 _mm_loadu_ps (float const* mem_address)
/// </summary>
- public static unsafe Vector128<float> Load(float* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<float> Load(float* address) => Load(address);
/// <summary>
/// __m128 _mm_load_ps (float const* mem_address)
/// </summary>
- public static unsafe Vector128<float> LoadAligned(float* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<float> LoadAligned(float* address) => LoadAligned(address);
/// <summary>
/// __m128 _mm_max_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> Max(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> Max(Vector128<float> left, Vector128<float> right) => Max(left, right);
/// <summary>
/// __m128 _mm_min_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> Min(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> Min(Vector128<float> left, Vector128<float> right) => Min(left, right);
/// <summary>
/// __m128 _mm_movehl_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> MoveHighToLow(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> MoveHighToLow(Vector128<float> left, Vector128<float> right) => MoveHighToLow(left, right);
/// <summary>
/// __m128 _mm_movelh_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> MoveLowToHigh(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> MoveLowToHigh(Vector128<float> left, Vector128<float> right) => MoveLowToHigh(left, right);
/// <summary>
/// __m128 _mm_mul_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right) => Multiply(left, right);
/// <summary>
/// __m128 _mm_or_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> Or(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> Or(Vector128<float> left, Vector128<float> right) => Or(left, right);
/// <summary>
/// __m128 _mm_rcp_ps (__m128 a)
/// </summary>
- public static Vector128<float> Reciprocal(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<float> Reciprocal(Vector128<float> value) => Reciprocal(value);
/// <summary>
/// __m128 _mm_rsqrt_ps (__m128 a)
/// </summary>
- public static Vector128<float> ReciprocalSquareRoot(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<float> ReciprocalSquareRoot(Vector128<float> value) => ReciprocalSquareRoot(value);
/// <summary>
/// __m128 _mm_set_ps (float e3, float e2, float e1, float e0)
/// </summary>
- public static Vector128<float> Set(float e3, float e2, float e1, float e0) { throw new NotImplementedException(); }
+ public static Vector128<float> Set(float e3, float e2, float e1, float e0) => Set(e3, e2, e1, e0);
/// <summary>
/// __m128 _mm_set1_ps (float a)
/// </summary>
- public static Vector128<float> Set1(float value) { throw new NotImplementedException(); }
+ public static Vector128<float> Set1(float value) => Set1(value);
/// <summary>
/// __m128d _mm_setzero_ps (void)
/// </summary>
- public static Vector128<float> SetZero() { throw new NotImplementedException(); }
+ public static Vector128<float> SetZero() => SetZero();
/// <summary>
/// __m128 _mm_castpd_ps (__m128d a)
/// __m128d _mm_castsi128_pd (__m128i a)
/// __m128 _mm_castsi128_ps (__m128i a)
/// </summary>
- public static Vector128<U> StaticCast<T, U>(Vector128<T> value) where T : struct where U : struct { throw new NotImplementedException(); }
+ public static Vector128<U> StaticCast<T, U>(Vector128<T> value) where T : struct where U : struct => StaticCast<T, U>(value);
/// <summary>
/// __m128 _mm_shuffle_ps (__m128 a, __m128 b, unsigned int control)
/// </summary>
- public static Vector128<float> Shuffle(Vector128<float> left, Vector128<float> right, byte control) { throw new NotImplementedException(); }
+ public static Vector128<float> Shuffle(Vector128<float> left, Vector128<float> right, byte control) => Shuffle(left, right, control);
/// <summary>
/// __m128 _mm_sqrt_ps (__m128 a)
/// </summary>
- public static Vector128<float> Sqrt(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<float> Sqrt(Vector128<float> value) => Sqrt(value);
/// <summary>
/// void _mm_store_ps (float* mem_addr, __m128 a)
/// </summary>
- public static unsafe void StoreAligned(float* address, Vector128<float> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(float* address, Vector128<float> source) => StoreAligned(address, source);
/// <summary>
/// void _mm_stream_ps (float* mem_addr, __m128 a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(float* address, Vector128<float> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(float* address, Vector128<float> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm_storeu_ps (float* mem_addr, __m128 a)
/// </summary>
- public static unsafe void Store(float* address, Vector128<float> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(float* address, Vector128<float> source) => Store(address, source);
/// <summary>
/// __m128d _mm_sub_ps (__m128d a, __m128d b)
/// </summary>
- public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right) => Subtract(left, right);
/// <summary>
/// __m128 _mm_unpackhi_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> UnpackHigh(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> UnpackHigh(Vector128<float> left, Vector128<float> right) => UnpackHigh(left, right);
/// <summary>
/// __m128 _mm_unpacklo_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> UnpackLow(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> UnpackLow(Vector128<float> left, Vector128<float> right) => UnpackLow(left, right);
/// <summary>
/// __m128 _mm_xor_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> Xor(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> Xor(Vector128<float> left, Vector128<float> right) => Xor(left, right);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel SSE2 hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Sse2
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// __m128i _mm_add_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_add_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_add_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> Add(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_add_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_add_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> Add(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_add_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_add_epi64 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<long> Add(Vector128<byte> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_add_epi64 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ulong> Add(Vector128<sbyte> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_add_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> Add(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_adds_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_adds_epu8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_adds_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_adds_epu16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_and_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> And(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_and_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> And(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_and_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> And(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_and_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> And(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_and_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> And(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_and_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<uint> And(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_and_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<long> And(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_and_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ulong> And(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_and_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> And(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> AndNot(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> AndNot(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> AndNot(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> AndNot(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> AndNot(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<uint> AndNot(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<long> AndNot(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ulong> AndNot(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_andnot_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> AndNot(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_avg_epu8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> Average(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_avg_epu16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> Average(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> CompareEqual(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> CompareEqual(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> CompareEqual(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> CompareEqual(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_cmpeq_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> CompareEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpgt_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cmpgt_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cmpgt_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_cmpgt_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> CompareGreaterThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_cmpge_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_cmplt_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> CompareLessThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_cmple_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_cmpneq_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> CompareNotEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_cmpngt_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> CompareNotGreaterThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_cmpnge_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> CompareNotGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_cmpnlt_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> CompareNotLessThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_cmpnle_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> CompareNotLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_cmpord_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> CompareOrdered(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_cmpunord_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> CompareUnordered(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cvtps_epi32 (__m128 a)
+ /// </summary>
+ public static Vector128<int> ConvertToInt(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvtpd_epi32 (__m128d a)
+ /// </summary>
+ public static Vector128<int> ConvertToInt(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128 _mm_cvtepi32_ps (__m128i a)
+ /// </summary>
+ public static Vector128<float> ConvertToFloat(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128 _mm_cvtpd_ps (__m128d a)
+ /// </summary>
+ public static Vector128<float> ConvertToFloat(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_cvtepi32_pd (__m128i a)
+ /// </summary>
+ public static Vector128<double> ConvertToDouble(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_cvtps_pd (__m128 a)
+ /// </summary>
+ public static Vector128<double> ConvertToDouble(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cvttps_epi32 (__m128 a)
+ /// </summary>
+ public static Vector128<int> ConvertToIntWithTruncation(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvttpd_epi32 (__m128d a)
+ /// </summary>
+ public static Vector128<int> ConvertToIntWithTruncation(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_div_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_extract_epi16 (__m128i a, int immediate)
+ /// </summary>
+ public static short ExtractShort<T>(Vector128<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// int _mm_extract_epi16 (__m128i a, int immediate)
+ /// </summary>
+ public static ushort ExtractUshort<T>(Vector128<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate)
+ /// </summary>
+ public static Vector128<T> InsertShort<T>(Vector128<T> value, short data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate)
+ /// </summary>
+ public static Vector128<T> InsertUshort<T>(Vector128<T> value, ushort data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<sbyte> Load(sbyte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<byte> Load(byte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<short> Load(short* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<ushort> Load(ushort* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<int> Load(int* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<uint> Load(uint* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<long> Load(long* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<ulong> Load(ulong* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_loadu_pd (double const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<double> Load(double* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_load_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<sbyte> LoadAligned(sbyte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_load_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<byte> LoadAligned(byte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_load_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<short> LoadAligned(short* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_load_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<ushort> LoadAligned(ushort* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_load_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<int> LoadAligned(int* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_load_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<uint> LoadAligned(uint* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_load_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<long> LoadAligned(long* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_load_si128 (__m128i const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<ulong> LoadAligned(ulong* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_load_pd (double const* mem_address)
+ /// </summary>
+ public static unsafe Vector128<double> LoadAligned(double* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address)
+ /// </summary>
+ public static unsafe void MaskMove(Vector128<sbyte> source, Vector128<sbyte> mask, sbyte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address)
+ /// </summary>
+ public static unsafe void MaskMove(Vector128<byte> source, Vector128<byte> mask, byte* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_max_epu8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_max_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> Max(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_max_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> Max(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_min_epu8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_min_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> Min(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_min_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> Min(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_movemask_epi8 (__m128i a)
+ /// </summary>
+ public static int MoveMask(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// int _mm_movemask_pd (__m128d a)
+ /// </summary>
+ public static int MoveMask(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_mul_epu32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ulong> Multiply(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_mul_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_mulhi_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> MultiplyHi(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_mulhi_epu16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> MultiplyHi(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_madd_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> MultiplyHorizontalAdd(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_mullo_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> MultiplyLow(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_or_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> Or(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_or_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> Or(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_or_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> Or(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_or_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> Or(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_or_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> Or(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_or_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<uint> Or(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_or_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<long> Or(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_or_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ulong> Or(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_or_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> Or(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_packs_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> PackSignedSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_packs_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> PackSignedSaturate(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_packus_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> PackUnsignedSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// ___m128i _mm_set_epi8 (char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0)
+ /// </summary>
+ public static Vector128<sbyte> Set(sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// ___m128i _mm_set_epi8 (char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0)
+ /// </summary>
+ public static Vector128<byte> Set(byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set_epi16 (short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0)
+ /// </summary>
+ public static Vector128<short> Set(short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set_epi16 (short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0)
+ /// </summary>
+ public static Vector128<ushort> Set(ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set_epi32 (int e3, int e2, int e1, int e0)
+ /// </summary>
+ public static Vector128<int> Set(int e3, int e2, int e1, int e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set_epi32 (int e3, int e2, int e1, int e0)
+ /// </summary>
+ public static Vector128<uint> Set(uint e3, uint e2, uint e1, uint e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set_epi64x (__int64 e1, __int64 e0)
+ /// </summary>
+ public static Vector128<long> Set(long e1, long e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set_epi64x (__int64 e1, __int64 e0)
+ /// </summary>
+ public static Vector128<ulong> Set(ulong e1, ulong e0) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_set_pd (double e1, double e0)
+ /// </summary>
+ public static Vector128<double> Set(double e1, double e0) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_set1_epi8 (char a)
+ /// </summary>
+ public static Vector128<byte> Set1(byte value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set1_epi8 (char a)
+ /// </summary>
+ public static Vector128<sbyte> Set1(sbyte value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set1_epi16 (short a)
+ /// </summary>
+ public static Vector128<short> Set1(short value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set1_epi16 (short a)
+ /// </summary>
+ public static Vector128<ushort> Set1(ushort value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set1_epi32 (int a)
+ /// </summary>
+ public static Vector128<int> Set1(int value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set1_epi32 (int a)
+ /// </summary>
+ public static Vector128<uint> Set1(uint value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set1_epi64x (long long a)
+ /// </summary>
+ public static Vector128<long> Set1(long value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_set1_epi64x (long long a)
+ /// </summary>
+ public static Vector128<ulong> Set1(ulong value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_set1_pd (double a)
+ /// </summary>
+ public static Vector128<double> Set1(double value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_setzero_si128 ()
+ /// __m128d _mm_setzero_pd (void)
+ /// </summary>
+ public static Vector128<T> SetZero<T>() where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_sad_epu8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<long> SumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<int> Shuffle(Vector128<int> value, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<uint> Shuffle(Vector128<uint> value, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_shuffle_pd (__m128d a, __m128d b, int immediate)
+ /// </summary>
+ public static Vector128<double> Shuffle(Vector128<double> left, Vector128<double> right, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_shufflehi_epi16 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<short> ShuffleHigh(Vector128<short> value, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_shufflehi_epi16 (__m128i a, int control)
+ /// </summary>
+ public static Vector128<ushort> ShuffleHigh(Vector128<ushort> value, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_shufflelo_epi16 (__m128i a, int control)
+ /// </summary>
+ public static Vector128<short> ShuffleLow(Vector128<short> value, byte control) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_shufflelo_epi16 (__m128i a, int control)
+ /// </summary>
+ public static Vector128<ushort> ShuffleLow(Vector128<ushort> value, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_slli_epi16 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_slli_epi16 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_slli_epi32 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_slli_epi32 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_slli_epi64 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_slli_epi64 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<sbyte> ShiftLeftLogical128BitLane(Vector128<sbyte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<byte> ShiftLeftLogical128BitLane(Vector128<byte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<short> ShiftLeftLogical128BitLane(Vector128<short> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<ushort> ShiftLeftLogical128BitLane(Vector128<ushort> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<int> ShiftLeftLogical128BitLane(Vector128<int> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<uint> ShiftLeftLogical128BitLane(Vector128<uint> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<long> ShiftLeftLogical128BitLane(Vector128<long> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<ulong> ShiftLeftLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_srai_epi16 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_srai_epi32 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_srli_epi16 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_srli_epi16 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_srli_epi32 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_srli_epi32 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_srli_epi64 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_srli_epi64 (__m128i a, int immediate)
+ /// </summary>
+ public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<sbyte> ShiftRightLogical128BitLane(Vector128<sbyte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<byte> ShiftRightLogical128BitLane(Vector128<byte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<short> ShiftRightLogical128BitLane(Vector128<short> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<ushort> ShiftRightLogical128BitLane(Vector128<ushort> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<int> ShiftRightLogical128BitLane(Vector128<int> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<uint> ShiftRightLogical128BitLane(Vector128<uint> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
+ /// </summary>
+ public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_sqrt_pd (__m128d a)
+ /// </summary>
+ public static Vector128<double> Sqrt(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAligned(sbyte* address, Vector128<sbyte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAligned(byte* address, Vector128<byte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAligned(short* address, Vector128<short> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAligned(ushort* address, Vector128<ushort> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAligned(int* address, Vector128<int> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAligned(uint* address, Vector128<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAligned(long* address, Vector128<long> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAligned(ulong* address, Vector128<ulong> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_store_pd (double* mem_addr, __m128d a)
+ /// </summary>
+ public static unsafe void StoreAligned(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector128<sbyte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(byte* address, Vector128<byte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(short* address, Vector128<short> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector128<ushort> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(int* address, Vector128<int> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(uint* address, Vector128<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(long* address, Vector128<long> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector128<ulong> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_stream_pd (double* mem_addr, __m128d a)
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void Store(sbyte* address, Vector128<sbyte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void Store(byte* address, Vector128<byte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void Store(short* address, Vector128<short> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void Store(ushort* address, Vector128<ushort> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void Store(int* address, Vector128<int> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void Store(uint* address, Vector128<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void Store(long* address, Vector128<long> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void Store(ulong* address, Vector128<ulong> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_storeu_pd (double* mem_addr, __m128d a)
+ /// </summary>
+ public static unsafe void Store(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm_storeh_pd (double* mem_addr, __m128d a)
+ /// </summary>
+ public static unsafe void StoreHigh(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreLow(long* address, Vector128<long> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a)
+ /// </summary>
+ public static unsafe void StoreLow(ulong* address, Vector128<ulong> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm_storel_pd (double* mem_addr, __m128d a)
+ /// </summary>
+ public static unsafe void StoreLow(double* address, Vector128<double> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_sub_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_sub_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_sub_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_sub_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_sub_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_sub_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_sub_epi64 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_sub_epi64 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_sub_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_subs_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_subs_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> SubtractSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_subs_epu8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_subs_epu16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> UnpackHigh(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> UnpackHigh(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> UnpackHigh(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b)
+ /// </summary
+ public static Vector128<ushort> UnpackHigh(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> UnpackHigh(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<uint> UnpackHigh(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<long> UnpackHigh(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ulong> UnpackHigh(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_unpackhi_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> UnpackHigh(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> UnpackLow(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> UnpackLow(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> UnpackLow(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> UnpackLow(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> UnpackLow(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<uint> UnpackLow(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<long> UnpackLow(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ulong> UnpackLow(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_unpacklo_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> UnpackLow(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_xor_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<byte> Xor(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_xor_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> Xor(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_xor_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> Xor(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_xor_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> Xor(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_xor_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> Xor(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_xor_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<uint> Xor(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_xor_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<long> Xor(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_xor_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ulong> Xor(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_xor_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> Xor(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+ }
+}
[CLSCompliant(false)]
public static class Sse2
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// __m128i _mm_add_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right) => Add(left, right);
/// <summary>
/// __m128i _mm_add_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right) => Add(left, right);
/// <summary>
/// __m128i _mm_add_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> Add(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> Add(Vector128<short> left, Vector128<short> right) => Add(left, right);
/// <summary>
/// __m128i _mm_add_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right) => Add(left, right);
/// <summary>
/// __m128i _mm_add_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> Add(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> Add(Vector128<int> left, Vector128<int> right) => Add(left, right);
/// <summary>
/// __m128i _mm_add_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
+ public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right) => Add(left, right);
/// <summary>
/// __m128i _mm_add_epi64 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<long> Add(Vector128<byte> left, Vector128<long> right) { throw new NotImplementedException(); }
+ public static Vector128<long> Add(Vector128<byte> left, Vector128<long> right) => Add(left, right);
/// <summary>
/// __m128i _mm_add_epi64 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ulong> Add(Vector128<sbyte> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static Vector128<ulong> Add(Vector128<sbyte> left, Vector128<ulong> right) => Add(left, right);
/// <summary>
/// __m128d _mm_add_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> Add(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> Add(Vector128<double> left, Vector128<double> right) => Add(left, right);
/// <summary>
/// __m128i _mm_adds_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right) => AddSaturate(left, right);
/// <summary>
/// __m128i _mm_adds_epu8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right) => AddSaturate(left, right);
/// <summary>
/// __m128i _mm_adds_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right) => AddSaturate(left, right);
/// <summary>
/// __m128i _mm_adds_epu16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right) => AddSaturate(left, right);
/// <summary>
/// __m128i _mm_and_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> And(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> And(Vector128<byte> left, Vector128<byte> right) => And(left, right);
/// <summary>
/// __m128i _mm_and_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> And(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> And(Vector128<sbyte> left, Vector128<sbyte> right) => And(left, right);
/// <summary>
/// __m128i _mm_and_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> And(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> And(Vector128<short> left, Vector128<short> right) => And(left, right);
/// <summary>
/// __m128i _mm_and_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> And(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> And(Vector128<ushort> left, Vector128<ushort> right) => And(left, right);
/// <summary>
/// __m128i _mm_and_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> And(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> And(Vector128<int> left, Vector128<int> right) => And(left, right);
/// <summary>
/// __m128i _mm_and_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<uint> And(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
+ public static Vector128<uint> And(Vector128<uint> left, Vector128<uint> right) => And(left, right);
/// <summary>
/// __m128i _mm_and_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<long> And(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
+ public static Vector128<long> And(Vector128<long> left, Vector128<long> right) => And(left, right);
/// <summary>
/// __m128i _mm_and_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ulong> And(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static Vector128<ulong> And(Vector128<ulong> left, Vector128<ulong> right) => And(left, right);
/// <summary>
/// __m128d _mm_and_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> And(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> And(Vector128<double> left, Vector128<double> right) => And(left, right);
/// <summary>
/// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> AndNot(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> AndNot(Vector128<byte> left, Vector128<byte> right) => AndNot(left, right);
/// <summary>
/// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> AndNot(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> AndNot(Vector128<sbyte> left, Vector128<sbyte> right) => AndNot(left, right);
/// <summary>
/// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> AndNot(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> AndNot(Vector128<short> left, Vector128<short> right) => AndNot(left, right);
/// <summary>
/// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> AndNot(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> AndNot(Vector128<ushort> left, Vector128<ushort> right) => AndNot(left, right);
/// <summary>
/// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> AndNot(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> AndNot(Vector128<int> left, Vector128<int> right) => AndNot(left, right);
/// <summary>
/// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<uint> AndNot(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
+ public static Vector128<uint> AndNot(Vector128<uint> left, Vector128<uint> right) => AndNot(left, right);
/// <summary>
/// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<long> AndNot(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
+ public static Vector128<long> AndNot(Vector128<long> left, Vector128<long> right) => AndNot(left, right);
/// <summary>
/// __m128i _mm_andnot_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ulong> AndNot(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static Vector128<ulong> AndNot(Vector128<ulong> left, Vector128<ulong> right) => AndNot(left, right);
/// <summary>
/// __m128d _mm_andnot_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> AndNot(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> AndNot(Vector128<double> left, Vector128<double> right) => AndNot(left, right);
/// <summary>
/// __m128i _mm_avg_epu8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> Average(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> Average(Vector128<byte> left, Vector128<byte> right) => Average(left, right);
/// <summary>
/// __m128i _mm_avg_epu16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> Average(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> Average(Vector128<ushort> left, Vector128<ushort> right) => Average(left, right);
/// <summary>
/// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left, Vector128<sbyte> right) => CompareEqual(left, right);
/// <summary>
/// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> CompareEqual(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> CompareEqual(Vector128<byte> left, Vector128<byte> right) => CompareEqual(left, right);
/// <summary>
/// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> CompareEqual(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> CompareEqual(Vector128<short> left, Vector128<short> right) => CompareEqual(left, right);
/// <summary>
/// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> CompareEqual(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> CompareEqual(Vector128<ushort> left, Vector128<ushort> right) => CompareEqual(left, right);
/// <summary>
/// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> CompareEqual(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> CompareEqual(Vector128<int> left, Vector128<int> right) => CompareEqual(left, right);
/// <summary>
/// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
+ public static Vector128<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right) => CompareEqual(left, right);
/// <summary>
/// __m128d _mm_cmpeq_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> CompareEqual(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> CompareEqual(Vector128<double> left, Vector128<double> right) => CompareEqual(left, right);
/// <summary>
/// __m128i _mm_cmpgt_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right) => CompareGreaterThan(left, right);
/// <summary>
/// __m128i _mm_cmpgt_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right) => CompareGreaterThan(left, right);
/// <summary>
/// __m128i _mm_cmpgt_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right) => CompareGreaterThan(left, right);
/// <summary>
/// __m128d _mm_cmpgt_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> CompareGreaterThan(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> CompareGreaterThan(Vector128<double> left, Vector128<double> right) => CompareGreaterThan(left, right);
/// <summary>
/// __m128d _mm_cmpge_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrEqual(left, right);
/// <summary>
/// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right) => CompareLessThan(left, right);
/// <summary>
/// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right) => CompareLessThan(left, right);
/// <summary>
/// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right) => CompareLessThan(left, right);
/// <summary>
/// __m128d _mm_cmplt_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> CompareLessThan(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> CompareLessThan(Vector128<double> left, Vector128<double> right) => CompareLessThan(left, right);
/// <summary>
/// __m128d _mm_cmple_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareLessThanOrEqual(left, right);
/// <summary>
/// __m128d _mm_cmpneq_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> CompareNotEqual(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> CompareNotEqual(Vector128<double> left, Vector128<double> right) => CompareNotEqual(left, right);
/// <summary>
/// __m128d _mm_cmpngt_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> CompareNotGreaterThan(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> CompareNotGreaterThan(Vector128<double> left, Vector128<double> right) => CompareNotGreaterThan(left, right);
/// <summary>
/// __m128d _mm_cmpnge_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> CompareNotGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> CompareNotGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareNotGreaterThanOrEqual(left, right);
/// <summary>
/// __m128d _mm_cmpnlt_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> CompareNotLessThan(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> CompareNotLessThan(Vector128<double> left, Vector128<double> right) => CompareNotLessThan(left, right);
/// <summary>
/// __m128d _mm_cmpnle_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> CompareNotLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> CompareNotLessThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareNotLessThanOrEqual(left, right);
/// <summary>
/// __m128d _mm_cmpord_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> CompareOrdered(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> CompareOrdered(Vector128<double> left, Vector128<double> right) => CompareOrdered(left, right);
/// <summary>
/// __m128d _mm_cmpunord_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> CompareUnordered(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> CompareUnordered(Vector128<double> left, Vector128<double> right) => CompareUnordered(left, right);
/// <summary>
/// __m128i _mm_cvtps_epi32 (__m128 a)
/// </summary>
- public static Vector128<int> ConvertToInt(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<int> ConvertToInt(Vector128<float> value) => ConvertToInt(value);
/// <summary>
/// __m128i _mm_cvtpd_epi32 (__m128d a)
/// </summary>
- public static Vector128<int> ConvertToInt(Vector128<double> value) { throw new NotImplementedException(); }
+ public static Vector128<int> ConvertToInt(Vector128<double> value) => ConvertToInt(value);
/// <summary>
/// __m128 _mm_cvtepi32_ps (__m128i a)
/// </summary>
- public static Vector128<float> ConvertToFloat(Vector128<int> value) { throw new NotImplementedException(); }
+ public static Vector128<float> ConvertToFloat(Vector128<int> value) => ConvertToFloat(value);
/// <summary>
/// __m128 _mm_cvtpd_ps (__m128d a)
/// </summary>
- public static Vector128<float> ConvertToFloat(Vector128<double> value) { throw new NotImplementedException(); }
+ public static Vector128<float> ConvertToFloat(Vector128<double> value) => ConvertToFloat(value);
/// <summary>
/// __m128d _mm_cvtepi32_pd (__m128i a)
/// </summary>
- public static Vector128<double> ConvertToDouble(Vector128<int> value) { throw new NotImplementedException(); }
+ public static Vector128<double> ConvertToDouble(Vector128<int> value) => ConvertToDouble(value);
/// <summary>
/// __m128d _mm_cvtps_pd (__m128 a)
/// </summary>
- public static Vector128<double> ConvertToDouble(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<double> ConvertToDouble(Vector128<float> value) => ConvertToDouble(value);
/// <summary>
/// __m128i _mm_cvttps_epi32 (__m128 a)
/// </summary>
- public static Vector128<int> ConvertToIntWithTruncation(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<int> ConvertToIntWithTruncation(Vector128<float> value) => ConvertToIntWithTruncation(value);
/// <summary>
/// __m128i _mm_cvttpd_epi32 (__m128d a)
/// </summary>
- public static Vector128<int> ConvertToIntWithTruncation(Vector128<double> value) { throw new NotImplementedException(); }
+ public static Vector128<int> ConvertToIntWithTruncation(Vector128<double> value) => ConvertToIntWithTruncation(value);
/// <summary>
/// __m128d _mm_div_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right) => Divide(left, right);
/// <summary>
/// int _mm_extract_epi16 (__m128i a, int immediate)
/// </summary>
- public static short ExtractShort<T>(Vector128<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static short ExtractShort<T>(Vector128<T> value, byte index) where T : struct => ExtractShort<T>(value, index);
/// <summary>
/// int _mm_extract_epi16 (__m128i a, int immediate)
/// </summary>
- public static ushort ExtractUshort<T>(Vector128<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static ushort ExtractUshort<T>(Vector128<T> value, byte index) where T : struct => ExtractUshort<T>(value, index);
/// <summary>
/// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate)
/// </summary>
- public static Vector128<T> InsertShort<T>(Vector128<T> value, short data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> InsertShort<T>(Vector128<T> value, short data, byte index) where T : struct => InsertShort<T>(value, data, index);
/// <summary>
/// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate)
/// </summary>
- public static Vector128<T> InsertUshort<T>(Vector128<T> value, ushort data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> InsertUshort<T>(Vector128<T> value, ushort data, byte index) where T : struct => InsertUshort<T>(value, data, index);
/// <summary>
/// __m128i _mm_loadu_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<sbyte> Load(sbyte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<sbyte> Load(sbyte* address) => Load(address);
/// <summary>
/// __m128i _mm_loadu_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<byte> Load(byte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<byte> Load(byte* address) => Load(address);
/// <summary>
/// __m128i _mm_loadu_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<short> Load(short* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<short> Load(short* address) => Load(address);
/// <summary>
/// __m128i _mm_loadu_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<ushort> Load(ushort* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<ushort> Load(ushort* address) => Load(address);
/// <summary>
/// __m128i _mm_loadu_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<int> Load(int* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<int> Load(int* address) => Load(address);
/// <summary>
/// __m128i _mm_loadu_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<uint> Load(uint* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<uint> Load(uint* address) => Load(address);
/// <summary>
/// __m128i _mm_loadu_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<long> Load(long* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<long> Load(long* address) => Load(address);
/// <summary>
/// __m128i _mm_loadu_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<ulong> Load(ulong* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<ulong> Load(ulong* address) => Load(address);
/// <summary>
/// __m128d _mm_loadu_pd (double const* mem_address)
/// </summary>
- public static unsafe Vector128<double> Load(double* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<double> Load(double* address) => Load(address);
/// <summary>
/// __m128i _mm_load_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<sbyte> LoadAligned(sbyte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<sbyte> LoadAligned(sbyte* address) => LoadAligned(address);
/// <summary>
/// __m128i _mm_load_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<byte> LoadAligned(byte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<byte> LoadAligned(byte* address) => LoadAligned(address);
/// <summary>
/// __m128i _mm_load_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<short> LoadAligned(short* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<short> LoadAligned(short* address) => LoadAligned(address);
/// <summary>
/// __m128i _mm_load_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<ushort> LoadAligned(ushort* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<ushort> LoadAligned(ushort* address) => LoadAligned(address);
/// <summary>
/// __m128i _mm_load_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<int> LoadAligned(int* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<int> LoadAligned(int* address) => LoadAligned(address);
/// <summary>
/// __m128i _mm_load_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<uint> LoadAligned(uint* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<uint> LoadAligned(uint* address) => LoadAligned(address);
/// <summary>
/// __m128i _mm_load_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<long> LoadAligned(long* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<long> LoadAligned(long* address) => LoadAligned(address);
/// <summary>
/// __m128i _mm_load_si128 (__m128i const* mem_address)
/// </summary>
- public static unsafe Vector128<ulong> LoadAligned(ulong* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<ulong> LoadAligned(ulong* address) => LoadAligned(address);
/// <summary>
/// __m128d _mm_load_pd (double const* mem_address)
/// </summary>
- public static unsafe Vector128<double> LoadAligned(double* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<double> LoadAligned(double* address) => LoadAligned(address);
/// <summary>
/// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address)
/// </summary>
- public static unsafe void MaskMove(Vector128<sbyte> source, Vector128<sbyte> mask, sbyte* address) { throw new NotImplementedException(); }
+ public static unsafe void MaskMove(Vector128<sbyte> source, Vector128<sbyte> mask, sbyte* address) => MaskMove(source, mask, address);
/// <summary>
/// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address)
/// </summary>
- public static unsafe void MaskMove(Vector128<byte> source, Vector128<byte> mask, byte* address) { throw new NotImplementedException(); }
+ public static unsafe void MaskMove(Vector128<byte> source, Vector128<byte> mask, byte* address) => MaskMove(source, mask, address);
/// <summary>
/// __m128i _mm_max_epu8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right) => Max(left, right);
/// <summary>
/// __m128i _mm_max_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> Max(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> Max(Vector128<short> left, Vector128<short> right) => Max(left, right);
/// <summary>
/// __m128d _mm_max_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> Max(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> Max(Vector128<double> left, Vector128<double> right) => Max(left, right);
/// <summary>
/// __m128i _mm_min_epu8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right) => Min(left, right);
/// <summary>
/// __m128i _mm_min_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> Min(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> Min(Vector128<short> left, Vector128<short> right) => Min(left, right);
/// <summary>
/// __m128d _mm_min_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> Min(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> Min(Vector128<double> left, Vector128<double> right) => Min(left, right);
/// <summary>
/// int _mm_movemask_epi8 (__m128i a)
/// </summary>
- public static int MoveMask(Vector128<sbyte> value) { throw new NotImplementedException(); }
+ public static int MoveMask(Vector128<sbyte> value) => MoveMask(value);
/// <summary>
/// int _mm_movemask_pd (__m128d a)
/// </summary>
- public static int MoveMask(Vector128<double> value) { throw new NotImplementedException(); }
+ public static int MoveMask(Vector128<double> value) => MoveMask(value);
/// <summary>
/// __m128i _mm_mul_epu32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ulong> Multiply(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
+ public static Vector128<ulong> Multiply(Vector128<uint> left, Vector128<uint> right) => Multiply(left, right);
/// <summary>
/// __m128d _mm_mul_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) => Multiply(left, right);
/// <summary>
/// __m128i _mm_mulhi_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> MultiplyHi(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> MultiplyHi(Vector128<short> left, Vector128<short> right) => MultiplyHi(left, right);
/// <summary>
/// __m128i _mm_mulhi_epu16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> MultiplyHi(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> MultiplyHi(Vector128<ushort> left, Vector128<ushort> right) => MultiplyHi(left, right);
/// <summary>
/// __m128i _mm_madd_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> MultiplyHorizontalAdd(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<int> MultiplyHorizontalAdd(Vector128<short> left, Vector128<short> right) => MultiplyHorizontalAdd(left, right);
/// <summary>
/// __m128i _mm_mullo_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> MultiplyLow(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> MultiplyLow(Vector128<short> left, Vector128<short> right) => MultiplyLow(left, right);
/// <summary>
/// __m128i _mm_or_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> Or(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> Or(Vector128<byte> left, Vector128<byte> right) => Or(left, right);
/// <summary>
/// __m128i _mm_or_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> Or(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> Or(Vector128<sbyte> left, Vector128<sbyte> right) => Or(left, right);
/// <summary>
/// __m128i _mm_or_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> Or(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> Or(Vector128<short> left, Vector128<short> right) => Or(left, right);
/// <summary>
/// __m128i _mm_or_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> Or(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> Or(Vector128<ushort> left, Vector128<ushort> right) => Or(left, right);
/// <summary>
/// __m128i _mm_or_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> Or(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> Or(Vector128<int> left, Vector128<int> right) => Or(left, right);
/// <summary>
/// __m128i _mm_or_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<uint> Or(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
+ public static Vector128<uint> Or(Vector128<uint> left, Vector128<uint> right) => Or(left, right);
/// <summary>
/// __m128i _mm_or_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<long> Or(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
+ public static Vector128<long> Or(Vector128<long> left, Vector128<long> right) => Or(left, right);
/// <summary>
/// __m128i _mm_or_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ulong> Or(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static Vector128<ulong> Or(Vector128<ulong> left, Vector128<ulong> right) => Or(left, right);
/// <summary>
/// __m128d _mm_or_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> Or(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> Or(Vector128<double> left, Vector128<double> right) => Or(left, right);
/// <summary>
/// __m128i _mm_packs_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> PackSignedSaturate(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> PackSignedSaturate(Vector128<short> left, Vector128<short> right) => PackSignedSaturate(left, right);
/// <summary>
/// __m128i _mm_packs_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> PackSignedSaturate(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<short> PackSignedSaturate(Vector128<int> left, Vector128<int> right) => PackSignedSaturate(left, right);
/// <summary>
/// __m128i _mm_packus_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> PackUnsignedSaturate(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> PackUnsignedSaturate(Vector128<short> left, Vector128<short> right) => PackUnsignedSaturate(left, right);
/// <summary>
/// ___m128i _mm_set_epi8 (char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0)
/// </summary>
- public static Vector128<sbyte> Set(sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> Set(sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) => Set(e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0);
/// <summary>
/// ___m128i _mm_set_epi8 (char e15, char e14, char e13, char e12, char e11, char e10, char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, char e1, char e0)
/// </summary>
- public static Vector128<byte> Set(byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) { throw new NotImplementedException(); }
+ public static Vector128<byte> Set(byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) => Set(e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0);
/// <summary>
/// __m128i _mm_set_epi16 (short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0)
/// </summary>
- public static Vector128<short> Set(short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) { throw new NotImplementedException(); }
+ public static Vector128<short> Set(short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) => Set(e7, e6, e5, e4, e3, e2, e1, e0);
/// <summary>
/// __m128i _mm_set_epi16 (short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0)
/// </summary>
- public static Vector128<ushort> Set(ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) { throw new NotImplementedException(); }
+ public static Vector128<ushort> Set(ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) => Set(e7, e6, e5, e4, e3, e2, e1, e0);
/// <summary>
/// __m128i _mm_set_epi32 (int e3, int e2, int e1, int e0)
/// </summary>
- public static Vector128<int> Set(int e3, int e2, int e1, int e0) { throw new NotImplementedException(); }
+ public static Vector128<int> Set(int e3, int e2, int e1, int e0) => Set(e3, e2, e1, e0);
/// <summary>
/// __m128i _mm_set_epi32 (int e3, int e2, int e1, int e0)
/// </summary>
- public static Vector128<uint> Set(uint e3, uint e2, uint e1, uint e0) { throw new NotImplementedException(); }
+ public static Vector128<uint> Set(uint e3, uint e2, uint e1, uint e0) => Set(e3, e2, e1, e0);
/// <summary>
/// __m128i _mm_set_epi64x (__int64 e1, __int64 e0)
/// </summary>
- public static Vector128<long> Set(long e1, long e0) { throw new NotImplementedException(); }
+ public static Vector128<long> Set(long e1, long e0) => Set(e1, e0);
/// <summary>
/// __m128i _mm_set_epi64x (__int64 e1, __int64 e0)
/// </summary>
- public static Vector128<ulong> Set(ulong e1, ulong e0) { throw new NotImplementedException(); }
+ public static Vector128<ulong> Set(ulong e1, ulong e0) => Set(e1, e0);
/// <summary>
/// __m128d _mm_set_pd (double e1, double e0)
/// </summary>
- public static Vector128<double> Set(double e1, double e0) { throw new NotImplementedException(); }
+ public static Vector128<double> Set(double e1, double e0) => Set(e1, e0);
/// <summary>
/// __m128i _mm_set1_epi8 (char a)
/// </summary>
- public static Vector128<byte> Set1(byte value) { throw new NotImplementedException(); }
+ public static Vector128<byte> Set1(byte value) => Set1(value);
/// <summary>
/// __m128i _mm_set1_epi8 (char a)
/// </summary>
- public static Vector128<sbyte> Set1(sbyte value) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> Set1(sbyte value) => Set1(value);
/// <summary>
/// __m128i _mm_set1_epi16 (short a)
/// </summary>
- public static Vector128<short> Set1(short value) { throw new NotImplementedException(); }
+ public static Vector128<short> Set1(short value) => Set1(value);
/// <summary>
/// __m128i _mm_set1_epi16 (short a)
/// </summary>
- public static Vector128<ushort> Set1(ushort value) { throw new NotImplementedException(); }
+ public static Vector128<ushort> Set1(ushort value) => Set1(value);
/// <summary>
/// __m128i _mm_set1_epi32 (int a)
/// </summary>
- public static Vector128<int> Set1(int value) { throw new NotImplementedException(); }
+ public static Vector128<int> Set1(int value) => Set1(value);
/// <summary>
/// __m128i _mm_set1_epi32 (int a)
/// </summary>
- public static Vector128<uint> Set1(uint value) { throw new NotImplementedException(); }
+ public static Vector128<uint> Set1(uint value) => Set1(value);
/// <summary>
/// __m128i _mm_set1_epi64x (long long a)
/// </summary>
- public static Vector128<long> Set1(long value) { throw new NotImplementedException(); }
+ public static Vector128<long> Set1(long value) => Set1(value);
/// <summary>
/// __m128i _mm_set1_epi64x (long long a)
/// </summary>
- public static Vector128<ulong> Set1(ulong value) { throw new NotImplementedException(); }
+ public static Vector128<ulong> Set1(ulong value) => Set1(value);
/// <summary>
/// __m128d _mm_set1_pd (double a)
/// </summary>
- public static Vector128<double> Set1(double value) { throw new NotImplementedException(); }
+ public static Vector128<double> Set1(double value) => Set1(value);
/// <summary>
/// __m128i _mm_setzero_si128 ()
/// __m128d _mm_setzero_pd (void)
/// </summary>
- public static Vector128<T> SetZero<T>() where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> SetZero<T>() where T : struct => SetZero<T>();
/// <summary>
/// __m128i _mm_sad_epu8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<long> SumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<long> SumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right) => SumAbsoluteDifferences(left, right);
/// <summary>
/// __m128i _mm_shuffle_epi32 (__m128i a, int immediate)
/// </summary>
- public static Vector128<int> Shuffle(Vector128<int> value, byte control) { throw new NotImplementedException(); }
+ public static Vector128<int> Shuffle(Vector128<int> value, byte control) => Shuffle(value, control);
/// <summary>
/// __m128i _mm_shuffle_epi32 (__m128i a, int immediate)
/// </summary>
- public static Vector128<uint> Shuffle(Vector128<uint> value, byte control) { throw new NotImplementedException(); }
+ public static Vector128<uint> Shuffle(Vector128<uint> value, byte control) => Shuffle(value, control);
/// <summary>
/// __m128d _mm_shuffle_pd (__m128d a, __m128d b, int immediate)
/// </summary>
- public static Vector128<double> Shuffle(Vector128<double> left, Vector128<double> right, byte control) { throw new NotImplementedException(); }
+ public static Vector128<double> Shuffle(Vector128<double> left, Vector128<double> right, byte control) => Shuffle(left, right, control);
/// <summary>
/// __m128i _mm_shufflehi_epi16 (__m128i a, int immediate)
/// </summary>
- public static Vector128<short> ShuffleHigh(Vector128<short> value, byte control) { throw new NotImplementedException(); }
+ public static Vector128<short> ShuffleHigh(Vector128<short> value, byte control) => ShuffleHigh(value, control);
/// <summary>
/// __m128i _mm_shufflehi_epi16 (__m128i a, int control)
/// </summary>
- public static Vector128<ushort> ShuffleHigh(Vector128<ushort> value, byte control) { throw new NotImplementedException(); }
+ public static Vector128<ushort> ShuffleHigh(Vector128<ushort> value, byte control) => ShuffleHigh(value, control);
/// <summary>
/// __m128i _mm_shufflelo_epi16 (__m128i a, int control)
/// </summary>
- public static Vector128<short> ShuffleLow(Vector128<short> value, byte control) { throw new NotImplementedException(); }
+ public static Vector128<short> ShuffleLow(Vector128<short> value, byte control) => ShuffleLow(value, control);
/// <summary>
/// __m128i _mm_shufflelo_epi16 (__m128i a, int control)
/// </summary>
- public static Vector128<ushort> ShuffleLow(Vector128<ushort> value, byte control) { throw new NotImplementedException(); }
+ public static Vector128<ushort> ShuffleLow(Vector128<ushort> value, byte control) => ShuffleLow(value, control);
/// <summary>
/// __m128i _mm_slli_epi16 (__m128i a, int immediate)
/// </summary>
- public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count) => ShiftLeftLogical(value, count);
/// <summary>
/// __m128i _mm_slli_epi16 (__m128i a, int immediate)
/// </summary>
- public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count) => ShiftLeftLogical(value, count);
/// <summary>
/// __m128i _mm_slli_epi32 (__m128i a, int immediate)
/// </summary>
- public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count) => ShiftLeftLogical(value, count);
/// <summary>
/// __m128i _mm_slli_epi32 (__m128i a, int immediate)
/// </summary>
- public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) => ShiftLeftLogical(value, count);
/// <summary>
/// __m128i _mm_slli_epi64 (__m128i a, int immediate)
/// </summary>
- public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count) => ShiftLeftLogical(value, count);
/// <summary>
/// __m128i _mm_slli_epi64 (__m128i a, int immediate)
/// </summary>
- public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) => ShiftLeftLogical(value, count);
/// <summary>
/// __m128i _mm_bslli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<sbyte> ShiftLeftLogical128BitLane(Vector128<sbyte> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> ShiftLeftLogical128BitLane(Vector128<sbyte> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bslli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<byte> ShiftLeftLogical128BitLane(Vector128<byte> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<byte> ShiftLeftLogical128BitLane(Vector128<byte> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bslli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<short> ShiftLeftLogical128BitLane(Vector128<short> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<short> ShiftLeftLogical128BitLane(Vector128<short> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bslli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<ushort> ShiftLeftLogical128BitLane(Vector128<ushort> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<ushort> ShiftLeftLogical128BitLane(Vector128<ushort> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bslli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<int> ShiftLeftLogical128BitLane(Vector128<int> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<int> ShiftLeftLogical128BitLane(Vector128<int> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bslli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<uint> ShiftLeftLogical128BitLane(Vector128<uint> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<uint> ShiftLeftLogical128BitLane(Vector128<uint> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bslli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<long> ShiftLeftLogical128BitLane(Vector128<long> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<long> ShiftLeftLogical128BitLane(Vector128<long> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bslli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<ulong> ShiftLeftLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<ulong> ShiftLeftLogical128BitLane(Vector128<ulong> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_srai_epi16 (__m128i a, int immediate)
/// </summary>
- public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count) => ShiftRightArithmetic(value, count);
/// <summary>
/// __m128i _mm_srai_epi32 (__m128i a, int immediate)
/// </summary>
- public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) => ShiftRightArithmetic(value, count);
/// <summary>
/// __m128i _mm_srli_epi16 (__m128i a, int immediate)
/// </summary>
- public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count) => ShiftRightLogical(value, count);
/// <summary>
/// __m128i _mm_srli_epi16 (__m128i a, int immediate)
/// </summary>
- public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count) => ShiftRightLogical(value, count);
/// <summary>
/// __m128i _mm_srli_epi32 (__m128i a, int immediate)
/// </summary>
- public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) => ShiftRightLogical(value, count);
/// <summary>
/// __m128i _mm_srli_epi32 (__m128i a, int immediate)
/// </summary>
- public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) => ShiftRightLogical(value, count);
/// <summary>
/// __m128i _mm_srli_epi64 (__m128i a, int immediate)
/// </summary>
- public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) => ShiftRightLogical(value, count);
/// <summary>
/// __m128i _mm_srli_epi64 (__m128i a, int immediate)
/// </summary>
- public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) { throw new NotImplementedException(); }
+ public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) => ShiftRightLogical(value, count);
/// <summary>
/// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<sbyte> ShiftRightLogical128BitLane(Vector128<sbyte> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> ShiftRightLogical128BitLane(Vector128<sbyte> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<byte> ShiftRightLogical128BitLane(Vector128<byte> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<byte> ShiftRightLogical128BitLane(Vector128<byte> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<short> ShiftRightLogical128BitLane(Vector128<short> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<short> ShiftRightLogical128BitLane(Vector128<short> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<ushort> ShiftRightLogical128BitLane(Vector128<ushort> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<ushort> ShiftRightLogical128BitLane(Vector128<ushort> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<int> ShiftRightLogical128BitLane(Vector128<int> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<int> ShiftRightLogical128BitLane(Vector128<int> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<uint> ShiftRightLogical128BitLane(Vector128<uint> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<uint> ShiftRightLogical128BitLane(Vector128<uint> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
/// </summary>
- public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw new NotImplementedException(); }
+ public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
/// <summary>
/// __m128d _mm_sqrt_pd (__m128d a)
/// </summary>
- public static Vector128<double> Sqrt(Vector128<double> value) { throw new NotImplementedException(); }
+ public static Vector128<double> Sqrt(Vector128<double> value) => Sqrt(value);
/// <summary>
/// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAligned(sbyte* address, Vector128<sbyte> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(sbyte* address, Vector128<sbyte> source) => StoreAligned(address, source);
/// <summary>
/// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAligned(byte* address, Vector128<byte> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(byte* address, Vector128<byte> source) => StoreAligned(address, source);
/// <summary>
/// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAligned(short* address, Vector128<short> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(short* address, Vector128<short> source) => StoreAligned(address, source);
/// <summary>
/// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAligned(ushort* address, Vector128<ushort> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(ushort* address, Vector128<ushort> source) => StoreAligned(address, source);
/// <summary>
/// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAligned(int* address, Vector128<int> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(int* address, Vector128<int> source) => StoreAligned(address, source);
/// <summary>
/// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAligned(uint* address, Vector128<uint> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(uint* address, Vector128<uint> source) => StoreAligned(address, source);
/// <summary>
/// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAligned(long* address, Vector128<long> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(long* address, Vector128<long> source) => StoreAligned(address, source);
/// <summary>
/// void _mm_store_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAligned(ulong* address, Vector128<ulong> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(ulong* address, Vector128<ulong> source) => StoreAligned(address, source);
/// <summary>
/// void _mm_store_pd (double* mem_addr, __m128d a)
/// </summary>
- public static unsafe void StoreAligned(double* address, Vector128<double> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAligned(double* address, Vector128<double> source) => StoreAligned(address, source);
/// <summary>
/// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector128<sbyte> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector128<sbyte> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(byte* address, Vector128<byte> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(byte* address, Vector128<byte> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(short* address, Vector128<short> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(short* address, Vector128<short> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector128<ushort> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector128<ushort> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(int* address, Vector128<int> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(int* address, Vector128<int> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(uint* address, Vector128<uint> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(uint* address, Vector128<uint> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(long* address, Vector128<long> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(long* address, Vector128<long> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector128<ulong> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector128<ulong> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm_stream_pd (double* mem_addr, __m128d a)
/// </summary>
- public static unsafe void StoreAlignedNonTemporal(double* address, Vector128<double> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreAlignedNonTemporal(double* address, Vector128<double> source) => StoreAlignedNonTemporal(address, source);
/// <summary>
/// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void Store(sbyte* address, Vector128<sbyte> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(sbyte* address, Vector128<sbyte> source) => Store(address, source);
/// <summary>
/// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void Store(byte* address, Vector128<byte> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(byte* address, Vector128<byte> source) => Store(address, source);
/// <summary>
/// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void Store(short* address, Vector128<short> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(short* address, Vector128<short> source) => Store(address, source);
/// <summary>
/// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void Store(ushort* address, Vector128<ushort> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(ushort* address, Vector128<ushort> source) => Store(address, source);
/// <summary>
/// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void Store(int* address, Vector128<int> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(int* address, Vector128<int> source) => Store(address, source);
/// <summary>
/// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void Store(uint* address, Vector128<uint> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(uint* address, Vector128<uint> source) => Store(address, source);
/// <summary>
/// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void Store(long* address, Vector128<long> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(long* address, Vector128<long> source) => Store(address, source);
/// <summary>
/// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void Store(ulong* address, Vector128<ulong> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(ulong* address, Vector128<ulong> source) => Store(address, source);
/// <summary>
/// void _mm_storeu_pd (double* mem_addr, __m128d a)
/// </summary>
- public static unsafe void Store(double* address, Vector128<double> source) { throw new NotImplementedException(); }
+ public static unsafe void Store(double* address, Vector128<double> source) => Store(address, source);
/// <summary>
/// void _mm_storeh_pd (double* mem_addr, __m128d a)
/// </summary>
- public static unsafe void StoreHigh(double* address, Vector128<double> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreHigh(double* address, Vector128<double> source) => StoreHigh(address, source);
/// <summary>
/// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreLow(long* address, Vector128<long> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreLow(long* address, Vector128<long> source) => StoreLow(address, source);
/// <summary>
/// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a)
/// </summary>
- public static unsafe void StoreLow(ulong* address, Vector128<ulong> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreLow(ulong* address, Vector128<ulong> source) => StoreLow(address, source);
/// <summary>
/// void _mm_storel_pd (double* mem_addr, __m128d a)
/// </summary>
- public static unsafe void StoreLow(double* address, Vector128<double> source) { throw new NotImplementedException(); }
+ public static unsafe void StoreLow(double* address, Vector128<double> source) => StoreLow(address, source);
/// <summary>
/// __m128i _mm_sub_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right) => Subtract(left, right);
/// <summary>
/// __m128i _mm_sub_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right) => Subtract(left, right);
/// <summary>
/// __m128i _mm_sub_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right) => Subtract(left, right);
/// <summary>
/// __m128i _mm_sub_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right) => Subtract(left, right);
/// <summary>
/// __m128i _mm_sub_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right) => Subtract(left, right);
/// <summary>
/// __m128i _mm_sub_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
+ public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right) => Subtract(left, right);
/// <summary>
/// __m128i _mm_sub_epi64 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
+ public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right) => Subtract(left, right);
/// <summary>
/// __m128i _mm_sub_epi64 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right) => Subtract(left, right);
/// <summary>
/// __m128d _mm_sub_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right) => Subtract(left, right);
/// <summary>
/// __m128i _mm_subs_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right) => SubtractSaturate(left, right);
/// <summary>
/// __m128i _mm_subs_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> SubtractSaturate(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> SubtractSaturate(Vector128<short> left, Vector128<short> right) => SubtractSaturate(left, right);
/// <summary>
/// __m128i _mm_subs_epu8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right) => SubtractSaturate(left, right);
/// <summary>
/// __m128i _mm_subs_epu16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right) => SubtractSaturate(left, right);
/// <summary>
/// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> UnpackHigh(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> UnpackHigh(Vector128<byte> left, Vector128<byte> right) => UnpackHigh(left, right);
/// <summary>
/// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> UnpackHigh(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> UnpackHigh(Vector128<sbyte> left, Vector128<sbyte> right) => UnpackHigh(left, right);
/// <summary>
/// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> UnpackHigh(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> UnpackHigh(Vector128<short> left, Vector128<short> right) => UnpackHigh(left, right);
/// <summary>
/// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b)
/// </summary
- public static Vector128<ushort> UnpackHigh(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> UnpackHigh(Vector128<ushort> left, Vector128<ushort> right) => UnpackHigh(left, right);
/// <summary>
/// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> UnpackHigh(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> UnpackHigh(Vector128<int> left, Vector128<int> right) => UnpackHigh(left, right);
/// <summary>
/// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<uint> UnpackHigh(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
+ public static Vector128<uint> UnpackHigh(Vector128<uint> left, Vector128<uint> right) => UnpackHigh(left, right);
/// <summary>
/// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<long> UnpackHigh(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
+ public static Vector128<long> UnpackHigh(Vector128<long> left, Vector128<long> right) => UnpackHigh(left, right);
/// <summary>
/// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ulong> UnpackHigh(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static Vector128<ulong> UnpackHigh(Vector128<ulong> left, Vector128<ulong> right) => UnpackHigh(left, right);
/// <summary>
/// __m128d _mm_unpackhi_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> UnpackHigh(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> UnpackHigh(Vector128<double> left, Vector128<double> right) => UnpackHigh(left, right);
/// <summary>
/// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> UnpackLow(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> UnpackLow(Vector128<byte> left, Vector128<byte> right) => UnpackLow(left, right);
/// <summary>
/// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> UnpackLow(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> UnpackLow(Vector128<sbyte> left, Vector128<sbyte> right) => UnpackLow(left, right);
/// <summary>
/// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> UnpackLow(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> UnpackLow(Vector128<short> left, Vector128<short> right) => UnpackLow(left, right);
/// <summary>
/// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> UnpackLow(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> UnpackLow(Vector128<ushort> left, Vector128<ushort> right) => UnpackLow(left, right);
/// <summary>
/// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> UnpackLow(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> UnpackLow(Vector128<int> left, Vector128<int> right) => UnpackLow(left, right);
/// <summary>
/// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<uint> UnpackLow(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
+ public static Vector128<uint> UnpackLow(Vector128<uint> left, Vector128<uint> right) => UnpackLow(left, right);
/// <summary>
/// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<long> UnpackLow(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
+ public static Vector128<long> UnpackLow(Vector128<long> left, Vector128<long> right) => UnpackLow(left, right);
/// <summary>
/// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ulong> UnpackLow(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static Vector128<ulong> UnpackLow(Vector128<ulong> left, Vector128<ulong> right) => UnpackLow(left, right);
/// <summary>
/// __m128d _mm_unpacklo_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> UnpackLow(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> UnpackLow(Vector128<double> left, Vector128<double> right) => UnpackLow(left, right);
/// <summary>
/// __m128i _mm_xor_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<byte> Xor(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
+ public static Vector128<byte> Xor(Vector128<byte> left, Vector128<byte> right) => Xor(left, right);
/// <summary>
/// __m128i _mm_xor_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> Xor(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> Xor(Vector128<sbyte> left, Vector128<sbyte> right) => Xor(left, right);
/// <summary>
/// __m128i _mm_xor_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> Xor(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> Xor(Vector128<short> left, Vector128<short> right) => Xor(left, right);
/// <summary>
/// __m128i _mm_xor_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> Xor(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> Xor(Vector128<ushort> left, Vector128<ushort> right) => Xor(left, right);
/// <summary>
/// __m128i _mm_xor_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> Xor(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> Xor(Vector128<int> left, Vector128<int> right) => Xor(left, right);
/// <summary>
/// __m128i _mm_xor_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<uint> Xor(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
+ public static Vector128<uint> Xor(Vector128<uint> left, Vector128<uint> right) => Xor(left, right);
/// <summary>
/// __m128i _mm_xor_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<long> Xor(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
+ public static Vector128<long> Xor(Vector128<long> left, Vector128<long> right) => Xor(left, right);
/// <summary>
/// __m128i _mm_xor_si128 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ulong> Xor(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static Vector128<ulong> Xor(Vector128<ulong> left, Vector128<ulong> right) => Xor(left, right);
/// <summary>
/// __m128d _mm_xor_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> Xor(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> Xor(Vector128<double> left, Vector128<double> right) => Xor(left, right);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel SSE3 hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Sse3
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// __m128 _mm_addsub_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> AddSubtract(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_addsub_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> AddSubtract(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_hadd_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> HorizontalAdd(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_hadd_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> HorizontalAdd(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_hsub_ps (__m128 a, __m128 b)
+ /// </summary>
+ public static Vector128<float> HorizontalSubtract(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_hsub_pd (__m128d a, __m128d b)
+ /// </summary>
+ public static Vector128<double> HorizontalSubtract(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_loaddup_pd (double const* mem_addr)
+ /// </summary>
+ public static unsafe Vector128<double> LoadAndDuplicate(double* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr)
+ /// </summary>
+ public static unsafe Vector128<sbyte> LoadDqu(sbyte* address) { throw new PlatformNotSupportedException(); }
+ public static unsafe Vector128<byte> LoadDqu(byte* address) { throw new PlatformNotSupportedException(); }
+ public static unsafe Vector128<short> LoadDqu(short* address) { throw new PlatformNotSupportedException(); }
+ public static unsafe Vector128<ushort> LoadDqu(ushort* address) { throw new PlatformNotSupportedException(); }
+ public static unsafe Vector128<int> LoadDqu(int* address) { throw new PlatformNotSupportedException(); }
+ public static unsafe Vector128<uint> LoadDqu(uint* address) { throw new PlatformNotSupportedException(); }
+ public static unsafe Vector128<long> LoadDqu(long* address) { throw new PlatformNotSupportedException(); }
+ public static unsafe Vector128<ulong> LoadDqu(ulong* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_movedup_pd (__m128d a)
+ /// </summary>
+ public static Vector128<double> MoveAndDuplicate(Vector128<double> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_movehdup_ps (__m128 a)
+ /// </summary>
+ public static Vector128<float> MoveHighAndDuplicate(Vector128<float> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_moveldup_ps (__m128 a)
+ /// </summary>
+ public static Vector128<float> MoveLowAndDuplicate(Vector128<float> source) { throw new PlatformNotSupportedException(); }
+
+ }
+}
[CLSCompliant(false)]
public static class Sse3
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// __m128 _mm_addsub_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> AddSubtract(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> AddSubtract(Vector128<float> left, Vector128<float> right) => AddSubtract(left, right);
/// <summary>
/// __m128d _mm_addsub_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> AddSubtract(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> AddSubtract(Vector128<double> left, Vector128<double> right) => AddSubtract(left, right);
/// <summary>
/// __m128 _mm_hadd_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> HorizontalAdd(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> HorizontalAdd(Vector128<float> left, Vector128<float> right) => HorizontalAdd(left, right);
/// <summary>
/// __m128d _mm_hadd_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> HorizontalAdd(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> HorizontalAdd(Vector128<double> left, Vector128<double> right) => HorizontalAdd(left, right);
/// <summary>
/// __m128 _mm_hsub_ps (__m128 a, __m128 b)
/// </summary>
- public static Vector128<float> HorizontalSubtract(Vector128<float> left, Vector128<float> right) { throw new NotImplementedException(); }
+ public static Vector128<float> HorizontalSubtract(Vector128<float> left, Vector128<float> right) => HorizontalSubtract(left, right);
/// <summary>
/// __m128d _mm_hsub_pd (__m128d a, __m128d b)
/// </summary>
- public static Vector128<double> HorizontalSubtract(Vector128<double> left, Vector128<double> right) { throw new NotImplementedException(); }
+ public static Vector128<double> HorizontalSubtract(Vector128<double> left, Vector128<double> right) => HorizontalSubtract(left, right);
/// <summary>
/// __m128d _mm_loaddup_pd (double const* mem_addr)
/// </summary>
- public static unsafe Vector128<double> LoadAndDuplicate(double* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<double> LoadAndDuplicate(double* address) => LoadAndDuplicate(address);
/// <summary>
/// __m128i _mm_lddqu_si128 (__m128i const* mem_addr)
/// </summary>
- public static unsafe Vector128<sbyte> LoadDqu(sbyte* address) { throw new NotImplementedException(); }
- public static unsafe Vector128<byte> LoadDqu(byte* address) { throw new NotImplementedException(); }
- public static unsafe Vector128<short> LoadDqu(short* address) { throw new NotImplementedException(); }
- public static unsafe Vector128<ushort> LoadDqu(ushort* address) { throw new NotImplementedException(); }
- public static unsafe Vector128<int> LoadDqu(int* address) { throw new NotImplementedException(); }
- public static unsafe Vector128<uint> LoadDqu(uint* address) { throw new NotImplementedException(); }
- public static unsafe Vector128<long> LoadDqu(long* address) { throw new NotImplementedException(); }
- public static unsafe Vector128<ulong> LoadDqu(ulong* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<sbyte> LoadDqu(sbyte* address) => LoadDqu(address);
+ public static unsafe Vector128<byte> LoadDqu(byte* address) => LoadDqu(address);
+ public static unsafe Vector128<short> LoadDqu(short* address) => LoadDqu(address);
+ public static unsafe Vector128<ushort> LoadDqu(ushort* address) => LoadDqu(address);
+ public static unsafe Vector128<int> LoadDqu(int* address) => LoadDqu(address);
+ public static unsafe Vector128<uint> LoadDqu(uint* address) => LoadDqu(address);
+ public static unsafe Vector128<long> LoadDqu(long* address) => LoadDqu(address);
+ public static unsafe Vector128<ulong> LoadDqu(ulong* address) => LoadDqu(address);
/// <summary>
/// __m128d _mm_movedup_pd (__m128d a)
/// </summary>
- public static Vector128<double> MoveAndDuplicate(Vector128<double> source) { throw new NotImplementedException(); }
+ public static Vector128<double> MoveAndDuplicate(Vector128<double> source) => MoveAndDuplicate(source);
/// <summary>
/// __m128 _mm_movehdup_ps (__m128 a)
/// </summary>
- public static Vector128<float> MoveHighAndDuplicate(Vector128<float> source) { throw new NotImplementedException(); }
+ public static Vector128<float> MoveHighAndDuplicate(Vector128<float> source) => MoveHighAndDuplicate(source);
/// <summary>
/// __m128 _mm_moveldup_ps (__m128 a)
/// </summary>
- public static Vector128<float> MoveLowAndDuplicate(Vector128<float> source) { throw new NotImplementedException(); }
+ public static Vector128<float> MoveLowAndDuplicate(Vector128<float> source) => MoveLowAndDuplicate(source);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel SSE4.1 hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Sse41
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<short> Blend(Vector128<short> left, Vector128<short> right, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<ushort> Blend(Vector128<ushort> left, Vector128<ushort> right, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_blend_ps (__m128 a, __m128 b, const int imm8)
+ /// </summary>
+ public static Vector128<float> Blend(Vector128<float> left, Vector128<float> right, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_blend_pd (__m128d a, __m128d b, const int imm8)
+ /// </summary>
+ public static Vector128<double> Blend(Vector128<double> left, Vector128<double> right, byte control) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask)
+ /// </summary>
+ public static Vector128<sbyte> BlendVariable(Vector128<sbyte> left, Vector128<sbyte> right, Vector128<sbyte> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask)
+ /// </summary>
+ public static Vector128<byte> BlendVariable(Vector128<byte> left, Vector128<byte> right, Vector128<byte> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128 _mm_blendv_ps (__m128 a, __m128 b, __m128 mask)
+ /// </summary>
+ public static Vector128<float> BlendVariable(Vector128<float> left, Vector128<float> right, Vector128<float> mask) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_blendv_pd (__m128d a, __m128d b, __m128d mask)
+ /// </summary>
+ public static Vector128<double> BlendVariable(Vector128<double> left, Vector128<double> right, Vector128<double> mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_ceil_ps (__m128 a)
+ /// </summary>
+ public static Vector128<float> Ceiling(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_ceil_pd (__m128d a)
+ /// </summary>
+ public static Vector128<double> Ceiling(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<long> CompareEqual(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ulong> CompareEqual(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cvtepi8_epi16 (__m128i a)
+ /// </summary>
+ public static Vector128<short> ConvertToShort(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvtepu8_epi16 (__m128i a)
+ /// </summary>
+ public static Vector128<short> ConvertToShort(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvtepi8_epi32 (__m128i a)
+ /// </summary>
+ public static Vector128<int> ConvertToInt(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvtepu8_epi32 (__m128i a)
+ /// </summary>
+ public static Vector128<int> ConvertToInt(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvtepi16_epi32 (__m128i a)
+ /// </summary>
+ public static Vector128<int> ConvertToInt(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvtepu16_epi32 (__m128i a)
+ /// </summary>
+ public static Vector128<int> ConvertToInt(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvtepi8_epi64 (__m128i a)
+ /// </summary>
+ public static Vector128<long> ConvertToLong(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvtepu8_epi64 (__m128i a)
+ /// </summary>
+ public static Vector128<long> ConvertToLong(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvtepi16_epi64 (__m128i a)
+ /// </summary>
+ public static Vector128<long> ConvertToLong(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvtepu16_epi64 (__m128i a)
+ /// </summary>
+ public static Vector128<long> ConvertToLong(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvtepi32_epi64 (__m128i a)
+ /// </summary>
+ public static Vector128<long> ConvertToLong(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_cvtepu32_epi64 (__m128i a)
+ /// </summary>
+ public static Vector128<long> ConvertToLong(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_extract_epi8 (__m128i a, const int imm8)
+ /// </summary>
+ public static sbyte ExtractSbyte<T>(Vector128<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// int _mm_extract_epi8 (__m128i a, const int imm8)
+ /// </summary>
+ public static byte ExtractByte<T>(Vector128<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_extract_epi32 (__m128i a, const int imm8)
+ /// </summary>
+ public static int ExtractInt<T>(Vector128<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_extract_epi32 (__m128i a, const int imm8)
+ /// </summary>
+ public static uint ExtractUint<T>(Vector128<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __int64 _mm_extract_epi64 (__m128i a, const int imm8)
+ /// </summary>
+ public static long ExtractLong<T>(Vector128<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __int64 _mm_extract_epi64 (__m128i a, const int imm8)
+ /// </summary>
+ public static ulong ExtractUlong<T>(Vector128<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_extract_ps (__m128 a, const int imm8)
+ /// </summary>
+ public static float ExtractFloat<T>(Vector128<T> value, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_floor_ps (__m128 a)
+ /// </summary>
+ public static Vector128<float> Floor(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128d _mm_floor_pd (__m128d a)
+ /// </summary>
+ public static Vector128<double> Floor(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8)
+ /// </summary>
+ public static Vector128<T> InsertSbyte<T>(Vector128<T> value, sbyte data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8)
+ /// </summary>
+ public static Vector128<T> InsertByte<T>(Vector128<T> value, byte data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8)
+ /// </summary>
+ public static Vector128<T> InsertInt<T>(Vector128<T> value, int data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8)
+ /// </summary>
+ public static Vector128<T> InsertUint<T>(Vector128<T> value, uint data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8)
+ /// </summary>
+ public static Vector128<T> InsertLong<T>(Vector128<T> value, long data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8)
+ /// </summary>
+ public static Vector128<T> InsertUlong<T>(Vector128<T> value, ulong data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_insert_ps (__m128 a, __m128 b, const int imm8)
+ /// </summary>
+ public static Vector128<T> InsertFloat<T>(Vector128<T> value, float data, byte index) where T : struct { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_max_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_max_epu16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_max_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> Max(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_max_epu32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_min_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_min_epu16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_min_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> Min(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_min_epu32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_minpos_epu16 (__m128i a)
+ /// </summary>
+ public static Vector128<ushort> MinHorizontal(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_mpsadbw_epu8 (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<ushort> MultipleSumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right, byte mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_mul_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<long> Multiply(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_mullo_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> MultiplyLow(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_packus_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<ushort> PackUnsignedSaturate(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128 _mm_round_ps (__m128 a, int rounding)
+ /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector128<float> RoundToNearestInteger(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector128<float> RoundToNegativeInfinity(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector128<float> RoundToPositiveInfinity(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector128<float> RoundToZero(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_CUR_DIRECTION
+ /// </summary>
+ public static Vector128<float> RoundCurrentDirection(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128d _mm_round_pd (__m128d a, int rounding)
+ /// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector128<double> RoundToNearestInteger(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector128<double> RoundToNegativeInfinity(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector128<double> RoundToPositiveInfinity(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC
+ /// </summary>
+ public static Vector128<double> RoundToZero(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// _MM_FROUND_CUR_DIRECTION
+ /// </summary>
+ public static Vector128<double> RoundCurrentDirection(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
+ /// </summary>
+ public static unsafe Vector128<sbyte> LoadAlignedNonTemporal(sbyte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
+ /// </summary>
+ public static unsafe Vector128<byte> LoadAlignedNonTemporal(byte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
+ /// </summary>
+ public static unsafe Vector128<short> LoadAlignedNonTemporal(short* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
+ /// </summary>
+ public static unsafe Vector128<ushort> LoadAlignedNonTemporal(ushort* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
+ /// </summary>
+ public static unsafe Vector128<int> LoadAlignedNonTemporal(int* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
+ /// </summary>
+ public static unsafe Vector128<uint> LoadAlignedNonTemporal(uint* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
+ /// </summary>
+ public static unsafe Vector128<long> LoadAlignedNonTemporal(long* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
+ /// </summary>
+ public static unsafe Vector128<ulong> LoadAlignedNonTemporal(ulong* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_test_all_ones (__m128i a)
+ /// </summary>
+ public static bool TestAllOnes(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllOnes(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllOnes(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllOnes(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllOnes(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllOnes(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllOnes(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllOnes(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_test_all_zeros (__m128i a, __m128i mask)
+ /// </summary>
+ public static bool TestAllZeros(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllZeros(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllZeros(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllZeros(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllZeros(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllZeros(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllZeros(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestAllZeros(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_testc_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static bool TestC(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestC(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestC(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestC(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestC(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestC(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestC(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestC(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_test_mix_ones_zeros (__m128i a, __m128i mask)
+ /// </summary>
+ public static bool TestMixOnesZeros(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestMixOnesZeros(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestMixOnesZeros(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestMixOnesZeros(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestMixOnesZeros(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestMixOnesZeros(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestMixOnesZeros(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestMixOnesZeros(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_testnzc_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static bool TestNotZAndNotC(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestNotZAndNotC(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestNotZAndNotC(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestNotZAndNotC(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestNotZAndNotC(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestNotZAndNotC(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestNotZAndNotC(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestNotZAndNotC(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_testz_si128 (__m128i a, __m128i b)
+ /// </summary>
+ public static bool TestZ(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestZ(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestZ(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestZ(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestZ(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestZ(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestZ(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ public static bool TestZ(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ }
+}
[CLSCompliant(false)]
public static class Sse41
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<short> Blend(Vector128<short> left, Vector128<short> right, byte control) { throw new NotImplementedException(); }
+ public static Vector128<short> Blend(Vector128<short> left, Vector128<short> right, byte control) => Blend(left, right, control);
/// <summary>
/// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<ushort> Blend(Vector128<ushort> left, Vector128<ushort> right, byte control) { throw new NotImplementedException(); }
+ public static Vector128<ushort> Blend(Vector128<ushort> left, Vector128<ushort> right, byte control) => Blend(left, right, control);
/// <summary>
/// __m128 _mm_blend_ps (__m128 a, __m128 b, const int imm8)
/// </summary>
- public static Vector128<float> Blend(Vector128<float> left, Vector128<float> right, byte control) { throw new NotImplementedException(); }
+ public static Vector128<float> Blend(Vector128<float> left, Vector128<float> right, byte control) => Blend(left, right, control);
/// <summary>
/// __m128d _mm_blend_pd (__m128d a, __m128d b, const int imm8)
/// </summary>
- public static Vector128<double> Blend(Vector128<double> left, Vector128<double> right, byte control) { throw new NotImplementedException(); }
+ public static Vector128<double> Blend(Vector128<double> left, Vector128<double> right, byte control) => Blend(left, right, control);
/// <summary>
/// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask)
/// </summary>
- public static Vector128<sbyte> BlendVariable(Vector128<sbyte> left, Vector128<sbyte> right, Vector128<sbyte> mask) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> BlendVariable(Vector128<sbyte> left, Vector128<sbyte> right, Vector128<sbyte> mask) => BlendVariable(left, right, mask);
/// <summary>
/// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask)
/// </summary>
- public static Vector128<byte> BlendVariable(Vector128<byte> left, Vector128<byte> right, Vector128<byte> mask) { throw new NotImplementedException(); }
+ public static Vector128<byte> BlendVariable(Vector128<byte> left, Vector128<byte> right, Vector128<byte> mask) => BlendVariable(left, right, mask);
/// <summary>
/// __m128 _mm_blendv_ps (__m128 a, __m128 b, __m128 mask)
/// </summary>
- public static Vector128<float> BlendVariable(Vector128<float> left, Vector128<float> right, Vector128<float> mask) { throw new NotImplementedException(); }
+ public static Vector128<float> BlendVariable(Vector128<float> left, Vector128<float> right, Vector128<float> mask) => BlendVariable(left, right, mask);
/// <summary>
/// __m128d _mm_blendv_pd (__m128d a, __m128d b, __m128d mask)
/// </summary>
- public static Vector128<double> BlendVariable(Vector128<double> left, Vector128<double> right, Vector128<double> mask) { throw new NotImplementedException(); }
+ public static Vector128<double> BlendVariable(Vector128<double> left, Vector128<double> right, Vector128<double> mask) => BlendVariable(left, right, mask);
/// <summary>
/// __m128 _mm_ceil_ps (__m128 a)
/// </summary>
- public static Vector128<float> Ceiling(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<float> Ceiling(Vector128<float> value) => Ceiling(value);
/// <summary>
/// __m128d _mm_ceil_pd (__m128d a)
/// </summary>
- public static Vector128<double> Ceiling(Vector128<double> value) { throw new NotImplementedException(); }
+ public static Vector128<double> Ceiling(Vector128<double> value) => Ceiling(value);
/// <summary>
/// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<long> CompareEqual(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
+ public static Vector128<long> CompareEqual(Vector128<long> left, Vector128<long> right) => CompareEqual(left, right);
/// <summary>
/// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ulong> CompareEqual(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static Vector128<ulong> CompareEqual(Vector128<ulong> left, Vector128<ulong> right) => CompareEqual(left, right);
/// <summary>
/// __m128i _mm_cvtepi8_epi16 (__m128i a)
/// </summary>
- public static Vector128<short> ConvertToShort(Vector128<sbyte> value) { throw new NotImplementedException(); }
+ public static Vector128<short> ConvertToShort(Vector128<sbyte> value) => ConvertToShort(value);
/// <summary>
/// __m128i _mm_cvtepu8_epi16 (__m128i a)
/// </summary>
- public static Vector128<short> ConvertToShort(Vector128<byte> value) { throw new NotImplementedException(); }
+ public static Vector128<short> ConvertToShort(Vector128<byte> value) => ConvertToShort(value);
/// <summary>
/// __m128i _mm_cvtepi8_epi32 (__m128i a)
/// </summary>
- public static Vector128<int> ConvertToInt(Vector128<sbyte> value) { throw new NotImplementedException(); }
+ public static Vector128<int> ConvertToInt(Vector128<sbyte> value) => ConvertToInt(value);
/// <summary>
/// __m128i _mm_cvtepu8_epi32 (__m128i a)
/// </summary>
- public static Vector128<int> ConvertToInt(Vector128<byte> value) { throw new NotImplementedException(); }
+ public static Vector128<int> ConvertToInt(Vector128<byte> value) => ConvertToInt(value);
/// <summary>
/// __m128i _mm_cvtepi16_epi32 (__m128i a)
/// </summary>
- public static Vector128<int> ConvertToInt(Vector128<short> value) { throw new NotImplementedException(); }
+ public static Vector128<int> ConvertToInt(Vector128<short> value) => ConvertToInt(value);
/// <summary>
/// __m128i _mm_cvtepu16_epi32 (__m128i a)
/// </summary>
- public static Vector128<int> ConvertToInt(Vector128<ushort> value) { throw new NotImplementedException(); }
+ public static Vector128<int> ConvertToInt(Vector128<ushort> value) => ConvertToInt(value);
/// <summary>
/// __m128i _mm_cvtepi8_epi64 (__m128i a)
/// </summary>
- public static Vector128<long> ConvertToLong(Vector128<sbyte> value) { throw new NotImplementedException(); }
+ public static Vector128<long> ConvertToLong(Vector128<sbyte> value) => ConvertToLong(value);
/// <summary>
/// __m128i _mm_cvtepu8_epi64 (__m128i a)
/// </summary>
- public static Vector128<long> ConvertToLong(Vector128<byte> value) { throw new NotImplementedException(); }
+ public static Vector128<long> ConvertToLong(Vector128<byte> value) => ConvertToLong(value);
/// <summary>
/// __m128i _mm_cvtepi16_epi64 (__m128i a)
/// </summary>
- public static Vector128<long> ConvertToLong(Vector128<short> value) { throw new NotImplementedException(); }
+ public static Vector128<long> ConvertToLong(Vector128<short> value) => ConvertToLong(value);
/// <summary>
/// __m128i _mm_cvtepu16_epi64 (__m128i a)
/// </summary>
- public static Vector128<long> ConvertToLong(Vector128<ushort> value) { throw new NotImplementedException(); }
+ public static Vector128<long> ConvertToLong(Vector128<ushort> value) => ConvertToLong(value);
/// <summary>
/// __m128i _mm_cvtepi32_epi64 (__m128i a)
/// </summary>
- public static Vector128<long> ConvertToLong(Vector128<int> value) { throw new NotImplementedException(); }
+ public static Vector128<long> ConvertToLong(Vector128<int> value) => ConvertToLong(value);
/// <summary>
/// __m128i _mm_cvtepu32_epi64 (__m128i a)
/// </summary>
- public static Vector128<long> ConvertToLong(Vector128<uint> value) { throw new NotImplementedException(); }
+ public static Vector128<long> ConvertToLong(Vector128<uint> value) => ConvertToLong(value);
/// <summary>
/// int _mm_extract_epi8 (__m128i a, const int imm8)
/// </summary>
- public static sbyte ExtractSbyte<T>(Vector128<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static sbyte ExtractSbyte<T>(Vector128<T> value, byte index) where T : struct => ExtractSbyte<T>(value, index);
/// <summary>
/// int _mm_extract_epi8 (__m128i a, const int imm8)
/// </summary>
- public static byte ExtractByte<T>(Vector128<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static byte ExtractByte<T>(Vector128<T> value, byte index) where T : struct => ExtractByte<T>(value, index);
/// <summary>
/// int _mm_extract_epi32 (__m128i a, const int imm8)
/// </summary>
- public static int ExtractInt<T>(Vector128<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static int ExtractInt<T>(Vector128<T> value, byte index) where T : struct => ExtractInt<T>(value, index);
/// <summary>
/// int _mm_extract_epi32 (__m128i a, const int imm8)
/// </summary>
- public static uint ExtractUint<T>(Vector128<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static uint ExtractUint<T>(Vector128<T> value, byte index) where T : struct => ExtractUint<T>(value, index);
/// <summary>
/// __int64 _mm_extract_epi64 (__m128i a, const int imm8)
/// </summary>
- public static long ExtractLong<T>(Vector128<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static long ExtractLong<T>(Vector128<T> value, byte index) where T : struct => ExtractLong<T>(value, index);
/// <summary>
/// __int64 _mm_extract_epi64 (__m128i a, const int imm8)
/// </summary>
- public static ulong ExtractUlong<T>(Vector128<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static ulong ExtractUlong<T>(Vector128<T> value, byte index) where T : struct => ExtractUlong<T>(value, index);
/// <summary>
/// int _mm_extract_ps (__m128 a, const int imm8)
/// </summary>
- public static float ExtractFloat<T>(Vector128<T> value, byte index) where T : struct { throw new NotImplementedException(); }
+ public static float ExtractFloat<T>(Vector128<T> value, byte index) where T : struct => ExtractFloat<T>(value, index);
/// <summary>
/// __m128 _mm_floor_ps (__m128 a)
/// </summary>
- public static Vector128<float> Floor(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<float> Floor(Vector128<float> value) => Floor(value);
/// <summary>
/// __m128d _mm_floor_pd (__m128d a)
/// </summary>
- public static Vector128<double> Floor(Vector128<double> value) { throw new NotImplementedException(); }
+ public static Vector128<double> Floor(Vector128<double> value) => Floor(value);
/// <summary>
/// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8)
/// </summary>
- public static Vector128<T> InsertSbyte<T>(Vector128<T> value, sbyte data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> InsertSbyte<T>(Vector128<T> value, sbyte data, byte index) where T : struct => InsertSbyte<T>(value, data, index);
/// <summary>
/// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8)
/// </summary>
- public static Vector128<T> InsertByte<T>(Vector128<T> value, byte data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> InsertByte<T>(Vector128<T> value, byte data, byte index) where T : struct => InsertByte<T>(value, data, index);
/// <summary>
/// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8)
/// </summary>
- public static Vector128<T> InsertInt<T>(Vector128<T> value, int data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> InsertInt<T>(Vector128<T> value, int data, byte index) where T : struct => InsertInt<T>(value, data, index);
/// <summary>
/// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8)
/// </summary>
- public static Vector128<T> InsertUint<T>(Vector128<T> value, uint data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> InsertUint<T>(Vector128<T> value, uint data, byte index) where T : struct => InsertUint<T>(value, data, index);
/// <summary>
/// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8)
/// </summary>
- public static Vector128<T> InsertLong<T>(Vector128<T> value, long data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> InsertLong<T>(Vector128<T> value, long data, byte index) where T : struct => InsertLong<T>(value, data, index);
/// <summary>
/// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8)
/// </summary>
- public static Vector128<T> InsertUlong<T>(Vector128<T> value, ulong data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> InsertUlong<T>(Vector128<T> value, ulong data, byte index) where T : struct => InsertUlong<T>(value, data, index);
/// <summary>
/// __m128 _mm_insert_ps (__m128 a, __m128 b, const int imm8)
/// </summary>
- public static Vector128<T> InsertFloat<T>(Vector128<T> value, float data, byte index) where T : struct { throw new NotImplementedException(); }
+ public static Vector128<T> InsertFloat<T>(Vector128<T> value, float data, byte index) where T : struct => InsertFloat<T>(value, data, index);
/// <summary>
/// __m128i _mm_max_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right) => Max(left, right);
/// <summary>
/// __m128i _mm_max_epu16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right) => Max(left, right);
/// <summary>
/// __m128i _mm_max_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> Max(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> Max(Vector128<int> left, Vector128<int> right) => Max(left, right);
/// <summary>
/// __m128i _mm_max_epu32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
+ public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right) => Max(left, right);
/// <summary>
/// __m128i _mm_min_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right) => Min(left, right);
/// <summary>
/// __m128i _mm_min_epu16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right) => Min(left, right);
/// <summary>
/// __m128i _mm_min_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> Min(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> Min(Vector128<int> left, Vector128<int> right) => Min(left, right);
/// <summary>
/// __m128i _mm_min_epu32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
+ public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right) => Min(left, right);
/// <summary>
/// __m128i _mm_minpos_epu16 (__m128i a)
/// </summary>
- public static Vector128<ushort> MinHorizontal(Vector128<ushort> value) { throw new NotImplementedException(); }
+ public static Vector128<ushort> MinHorizontal(Vector128<ushort> value) => MinHorizontal(value);
/// <summary>
/// __m128i _mm_mpsadbw_epu8 (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<ushort> MultipleSumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right, byte mask) { throw new NotImplementedException(); }
+ public static Vector128<ushort> MultipleSumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right, byte mask) => MultipleSumAbsoluteDifferences(left, right, mask);
/// <summary>
/// __m128i _mm_mul_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<long> Multiply(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<long> Multiply(Vector128<int> left, Vector128<int> right) => Multiply(left, right);
/// <summary>
/// __m128i _mm_mullo_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> MultiplyLow(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> MultiplyLow(Vector128<int> left, Vector128<int> right) => MultiplyLow(left, right);
/// <summary>
/// __m128i _mm_packus_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<ushort> PackUnsignedSaturate(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<ushort> PackUnsignedSaturate(Vector128<int> left, Vector128<int> right) => PackUnsignedSaturate(left, right);
/// <summary>
/// __m128 _mm_round_ps (__m128 a, int rounding)
/// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector128<float> RoundToNearestInteger(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<float> RoundToNearestInteger(Vector128<float> value) => RoundToNearestInteger(value);
/// <summary>
/// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector128<float> RoundToNegativeInfinity(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<float> RoundToNegativeInfinity(Vector128<float> value) => RoundToNegativeInfinity(value);
/// <summary>
/// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector128<float> RoundToPositiveInfinity(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<float> RoundToPositiveInfinity(Vector128<float> value) => RoundToPositiveInfinity(value);
/// <summary>
/// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector128<float> RoundToZero(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<float> RoundToZero(Vector128<float> value) => RoundToZero(value);
/// <summary>
/// _MM_FROUND_CUR_DIRECTION
/// </summary>
- public static Vector128<float> RoundCurrentDirection(Vector128<float> value) { throw new NotImplementedException(); }
+ public static Vector128<float> RoundCurrentDirection(Vector128<float> value) => RoundCurrentDirection(value);
/// <summary>
/// __m128d _mm_round_pd (__m128d a, int rounding)
/// _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector128<double> RoundToNearestInteger(Vector128<double> value) { throw new NotImplementedException(); }
+ public static Vector128<double> RoundToNearestInteger(Vector128<double> value) => RoundToNearestInteger(value);
/// <summary>
/// _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector128<double> RoundToNegativeInfinity(Vector128<double> value) { throw new NotImplementedException(); }
+ public static Vector128<double> RoundToNegativeInfinity(Vector128<double> value) => RoundToNegativeInfinity(value);
/// <summary>
/// _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector128<double> RoundToPositiveInfinity(Vector128<double> value) { throw new NotImplementedException(); }
+ public static Vector128<double> RoundToPositiveInfinity(Vector128<double> value) => RoundToPositiveInfinity(value);
/// <summary>
/// _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC
/// </summary>
- public static Vector128<double> RoundToZero(Vector128<double> value) { throw new NotImplementedException(); }
+ public static Vector128<double> RoundToZero(Vector128<double> value) => RoundToZero(value);
/// <summary>
/// _MM_FROUND_CUR_DIRECTION
/// </summary>
- public static Vector128<double> RoundCurrentDirection(Vector128<double> value) { throw new NotImplementedException(); }
+ public static Vector128<double> RoundCurrentDirection(Vector128<double> value) => RoundCurrentDirection(value);
/// <summary>
/// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
/// </summary>
- public static unsafe Vector128<sbyte> LoadAlignedNonTemporal(sbyte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<sbyte> LoadAlignedNonTemporal(sbyte* address) => LoadAlignedNonTemporal(address);
/// <summary>
/// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
/// </summary>
- public static unsafe Vector128<byte> LoadAlignedNonTemporal(byte* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<byte> LoadAlignedNonTemporal(byte* address) => LoadAlignedNonTemporal(address);
/// <summary>
/// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
/// </summary>
- public static unsafe Vector128<short> LoadAlignedNonTemporal(short* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<short> LoadAlignedNonTemporal(short* address) => LoadAlignedNonTemporal(address);
/// <summary>
/// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
/// </summary>
- public static unsafe Vector128<ushort> LoadAlignedNonTemporal(ushort* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<ushort> LoadAlignedNonTemporal(ushort* address) => LoadAlignedNonTemporal(address);
/// <summary>
/// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
/// </summary>
- public static unsafe Vector128<int> LoadAlignedNonTemporal(int* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<int> LoadAlignedNonTemporal(int* address) => LoadAlignedNonTemporal(address);
/// <summary>
/// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
/// </summary>
- public static unsafe Vector128<uint> LoadAlignedNonTemporal(uint* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<uint> LoadAlignedNonTemporal(uint* address) => LoadAlignedNonTemporal(address);
/// <summary>
/// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
/// </summary>
- public static unsafe Vector128<long> LoadAlignedNonTemporal(long* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<long> LoadAlignedNonTemporal(long* address) => LoadAlignedNonTemporal(address);
/// <summary>
/// __m128i _mm_stream_load_si128 (const __m128i* mem_addr)
/// </summary>
- public static unsafe Vector128<ulong> LoadAlignedNonTemporal(ulong* address) { throw new NotImplementedException(); }
+ public static unsafe Vector128<ulong> LoadAlignedNonTemporal(ulong* address) => LoadAlignedNonTemporal(address);
/// <summary>
/// int _mm_test_all_ones (__m128i a)
/// </summary>
- public static bool TestAllOnes(Vector128<sbyte> value) { throw new NotImplementedException(); }
- public static bool TestAllOnes(Vector128<byte> value) { throw new NotImplementedException(); }
- public static bool TestAllOnes(Vector128<short> value) { throw new NotImplementedException(); }
- public static bool TestAllOnes(Vector128<ushort> value) { throw new NotImplementedException(); }
- public static bool TestAllOnes(Vector128<int> value) { throw new NotImplementedException(); }
- public static bool TestAllOnes(Vector128<uint> value) { throw new NotImplementedException(); }
- public static bool TestAllOnes(Vector128<long> value) { throw new NotImplementedException(); }
- public static bool TestAllOnes(Vector128<ulong> value) { throw new NotImplementedException(); }
+ public static bool TestAllOnes(Vector128<sbyte> value) => TestAllOnes(value);
+ public static bool TestAllOnes(Vector128<byte> value) => TestAllOnes(value);
+ public static bool TestAllOnes(Vector128<short> value) => TestAllOnes(value);
+ public static bool TestAllOnes(Vector128<ushort> value) => TestAllOnes(value);
+ public static bool TestAllOnes(Vector128<int> value) => TestAllOnes(value);
+ public static bool TestAllOnes(Vector128<uint> value) => TestAllOnes(value);
+ public static bool TestAllOnes(Vector128<long> value) => TestAllOnes(value);
+ public static bool TestAllOnes(Vector128<ulong> value) => TestAllOnes(value);
/// <summary>
/// int _mm_test_all_zeros (__m128i a, __m128i mask)
/// </summary>
- public static bool TestAllZeros(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
- public static bool TestAllZeros(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
- public static bool TestAllZeros(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
- public static bool TestAllZeros(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
- public static bool TestAllZeros(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
- public static bool TestAllZeros(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
- public static bool TestAllZeros(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
- public static bool TestAllZeros(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static bool TestAllZeros(Vector128<sbyte> left, Vector128<sbyte> right) => TestAllZeros(left, right);
+ public static bool TestAllZeros(Vector128<byte> left, Vector128<byte> right) => TestAllZeros(left, right);
+ public static bool TestAllZeros(Vector128<short> left, Vector128<short> right) => TestAllZeros(left, right);
+ public static bool TestAllZeros(Vector128<ushort> left, Vector128<ushort> right) => TestAllZeros(left, right);
+ public static bool TestAllZeros(Vector128<int> left, Vector128<int> right) => TestAllZeros(left, right);
+ public static bool TestAllZeros(Vector128<uint> left, Vector128<uint> right) => TestAllZeros(left, right);
+ public static bool TestAllZeros(Vector128<long> left, Vector128<long> right) => TestAllZeros(left, right);
+ public static bool TestAllZeros(Vector128<ulong> left, Vector128<ulong> right) => TestAllZeros(left, right);
/// <summary>
/// int _mm_testc_si128 (__m128i a, __m128i b)
/// </summary>
- public static bool TestC(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
- public static bool TestC(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
- public static bool TestC(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
- public static bool TestC(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
- public static bool TestC(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
- public static bool TestC(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
- public static bool TestC(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
- public static bool TestC(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static bool TestC(Vector128<sbyte> left, Vector128<sbyte> right) => TestC(left, right);
+ public static bool TestC(Vector128<byte> left, Vector128<byte> right) => TestC(left, right);
+ public static bool TestC(Vector128<short> left, Vector128<short> right) => TestC(left, right);
+ public static bool TestC(Vector128<ushort> left, Vector128<ushort> right) => TestC(left, right);
+ public static bool TestC(Vector128<int> left, Vector128<int> right) => TestC(left, right);
+ public static bool TestC(Vector128<uint> left, Vector128<uint> right) => TestC(left, right);
+ public static bool TestC(Vector128<long> left, Vector128<long> right) => TestC(left, right);
+ public static bool TestC(Vector128<ulong> left, Vector128<ulong> right) => TestC(left, right);
/// <summary>
/// int _mm_test_mix_ones_zeros (__m128i a, __m128i mask)
/// </summary>
- public static bool TestMixOnesZeros(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
- public static bool TestMixOnesZeros(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
- public static bool TestMixOnesZeros(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
- public static bool TestMixOnesZeros(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
- public static bool TestMixOnesZeros(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
- public static bool TestMixOnesZeros(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
- public static bool TestMixOnesZeros(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
- public static bool TestMixOnesZeros(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static bool TestMixOnesZeros(Vector128<sbyte> left, Vector128<sbyte> right) => TestMixOnesZeros(left, right);
+ public static bool TestMixOnesZeros(Vector128<byte> left, Vector128<byte> right) => TestMixOnesZeros(left, right);
+ public static bool TestMixOnesZeros(Vector128<short> left, Vector128<short> right) => TestMixOnesZeros(left, right);
+ public static bool TestMixOnesZeros(Vector128<ushort> left, Vector128<ushort> right) => TestMixOnesZeros(left, right);
+ public static bool TestMixOnesZeros(Vector128<int> left, Vector128<int> right) => TestMixOnesZeros(left, right);
+ public static bool TestMixOnesZeros(Vector128<uint> left, Vector128<uint> right) => TestMixOnesZeros(left, right);
+ public static bool TestMixOnesZeros(Vector128<long> left, Vector128<long> right) => TestMixOnesZeros(left, right);
+ public static bool TestMixOnesZeros(Vector128<ulong> left, Vector128<ulong> right) => TestMixOnesZeros(left, right);
/// <summary>
/// int _mm_testnzc_si128 (__m128i a, __m128i b)
/// </summary>
- public static bool TestNotZAndNotC(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
- public static bool TestNotZAndNotC(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
- public static bool TestNotZAndNotC(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
- public static bool TestNotZAndNotC(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
- public static bool TestNotZAndNotC(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
- public static bool TestNotZAndNotC(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
- public static bool TestNotZAndNotC(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
- public static bool TestNotZAndNotC(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static bool TestNotZAndNotC(Vector128<sbyte> left, Vector128<sbyte> right) => TestNotZAndNotC(left, right);
+ public static bool TestNotZAndNotC(Vector128<byte> left, Vector128<byte> right) => TestNotZAndNotC(left, right);
+ public static bool TestNotZAndNotC(Vector128<short> left, Vector128<short> right) => TestNotZAndNotC(left, right);
+ public static bool TestNotZAndNotC(Vector128<ushort> left, Vector128<ushort> right) => TestNotZAndNotC(left, right);
+ public static bool TestNotZAndNotC(Vector128<int> left, Vector128<int> right) => TestNotZAndNotC(left, right);
+ public static bool TestNotZAndNotC(Vector128<uint> left, Vector128<uint> right) => TestNotZAndNotC(left, right);
+ public static bool TestNotZAndNotC(Vector128<long> left, Vector128<long> right) => TestNotZAndNotC(left, right);
+ public static bool TestNotZAndNotC(Vector128<ulong> left, Vector128<ulong> right) => TestNotZAndNotC(left, right);
/// <summary>
/// int _mm_testz_si128 (__m128i a, __m128i b)
/// </summary>
- public static bool TestZ(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
- public static bool TestZ(Vector128<byte> left, Vector128<byte> right) { throw new NotImplementedException(); }
- public static bool TestZ(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
- public static bool TestZ(Vector128<ushort> left, Vector128<ushort> right) { throw new NotImplementedException(); }
- public static bool TestZ(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
- public static bool TestZ(Vector128<uint> left, Vector128<uint> right) { throw new NotImplementedException(); }
- public static bool TestZ(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
- public static bool TestZ(Vector128<ulong> left, Vector128<ulong> right) { throw new NotImplementedException(); }
+ public static bool TestZ(Vector128<sbyte> left, Vector128<sbyte> right) => TestZ(left, right);
+ public static bool TestZ(Vector128<byte> left, Vector128<byte> right) => TestZ(left, right);
+ public static bool TestZ(Vector128<short> left, Vector128<short> right) => TestZ(left, right);
+ public static bool TestZ(Vector128<ushort> left, Vector128<ushort> right) => TestZ(left, right);
+ public static bool TestZ(Vector128<int> left, Vector128<int> right) => TestZ(left, right);
+ public static bool TestZ(Vector128<uint> left, Vector128<uint> right) => TestZ(left, right);
+ public static bool TestZ(Vector128<long> left, Vector128<long> right) => TestZ(left, right);
+ public static bool TestZ(Vector128<ulong> left, Vector128<ulong> right) => TestZ(left, right);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel SSE4.2 hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Sse42
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// int _mm_cmpistra (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistrc (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistro (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static bool CompareImplicitLength(Vector128<sbyte> left, Vector128<sbyte> right, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpistra (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistrc (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistro (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static bool CompareImplicitLength(Vector128<byte> left, Vector128<byte> right, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpistra (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistrc (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistro (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static bool CompareImplicitLength(Vector128<short> left, Vector128<short> right, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+
+ /// <summary>
+ /// int _mm_cmpistra (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistrc (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistro (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8)
+ /// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static bool CompareImplicitLength(Vector128<ushort> left, Vector128<ushort> right, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestrc (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestro (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static bool CompareExplicitLength(Vector128<sbyte> left, byte leftLength, Vector128<sbyte> right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestrc (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestro (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static bool CompareExplicitLength(Vector128<byte> left, byte leftLength, Vector128<byte> right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestrc (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestro (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static bool CompareExplicitLength(Vector128<short> left, byte leftLength, Vector128<short> right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestrc (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestro (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static bool CompareExplicitLength(Vector128<ushort> left, byte leftLength, Vector128<ushort> right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpistri (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static int CompareImplicitLengthIndex(Vector128<sbyte> left, Vector128<sbyte> right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpistri (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static int CompareImplicitLengthIndex(Vector128<byte> left, Vector128<byte> right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpistri (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static int CompareImplicitLengthIndex(Vector128<short> left, Vector128<short> right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpistri (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static int CompareImplicitLengthIndex(Vector128<ushort> left, Vector128<ushort> right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static int CompareExplicitLengthIndex(Vector128<sbyte> left, byte leftLength, Vector128<sbyte> right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static int CompareExplicitLengthIndex(Vector128<byte> left, byte leftLength, Vector128<byte> right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static int CompareExplicitLengthIndex(Vector128<short> left, byte leftLength, Vector128<short> right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static int CompareExplicitLengthIndex(Vector128<ushort> left, byte leftLength, Vector128<ushort> right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<ushort> CompareImplicitLengthBitMask(Vector128<sbyte> left, Vector128<sbyte> right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<ushort> CompareImplicitLengthBitMask(Vector128<byte> left, Vector128<byte> right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<byte> CompareImplicitLengthBitMask(Vector128<short> left, Vector128<short> right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<byte> CompareImplicitLengthBitMask(Vector128<ushort> left, Vector128<ushort> right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<byte> CompareImplicitLengthUnitMask(Vector128<sbyte> left, Vector128<sbyte> right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<byte> CompareImplicitLengthUnitMask(Vector128<byte> left, Vector128<byte> right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<ushort> CompareImplicitLengthUnitMask(Vector128<short> left, Vector128<short> right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
+ /// </summary>
+ public static Vector128<ushort> CompareImplicitLengthUnitMask(Vector128<ushort> left, Vector128<ushort> right, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static Vector128<ushort> CompareExplicitLengthBitMask(Vector128<sbyte> left, byte leftLength, Vector128<sbyte> right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static Vector128<ushort> CompareExplicitLengthBitMask(Vector128<byte> left, byte leftLength, Vector128<byte> right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static Vector128<byte> CompareExplicitLengthBitMask(Vector128<short> left, byte leftLength, Vector128<short> right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static Vector128<byte> CompareExplicitLengthBitMask(Vector128<ushort> left, byte leftLength, Vector128<ushort> right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static Vector128<byte> CompareExplicitLengthUnitMask(Vector128<sbyte> left, byte leftLength, Vector128<sbyte> right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static Vector128<byte> CompareExplicitLengthUnitMask(Vector128<byte> left, byte leftLength, Vector128<byte> right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static Vector128<ushort> CompareExplicitLengthUnitMask(Vector128<short> left, byte leftLength, Vector128<short> right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
+ /// </summary>
+ public static Vector128<ushort> CompareExplicitLengthUnitMask(Vector128<ushort> left, byte leftLength, Vector128<ushort> right, byte rightLength, StringComparisonMode mode) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_cmpgt_epi64 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<long> CompareGreaterThan(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// unsigned int _mm_crc32_u8 (unsigned int crc, unsigned char v)
+ /// </summary>
+ public static uint Crc32(uint crc, byte data) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned int _mm_crc32_u16 (unsigned int crc, unsigned short v)
+ /// </summary>
+ public static uint Crc32(uint crc, ushort data) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned int _mm_crc32_u32 (unsigned int crc, unsigned int v)
+ /// </summary>
+ public static uint Crc32(uint crc, uint data) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// unsigned __int64 _mm_crc32_u64 (unsigned __int64 crc, unsigned __int64 v)
+ /// </summary>
+ public static ulong Crc32(ulong crc, ulong data) { throw new PlatformNotSupportedException(); }
+ }
+}
[CLSCompliant(false)]
public static class Sse42
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// int _mm_cmpistra (__m128i a, __m128i b, const int imm8)
/// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8)
/// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static bool CompareImplicitLength(Vector128<sbyte> left, Vector128<sbyte> right, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static bool CompareImplicitLength(Vector128<sbyte> left, Vector128<sbyte> right, ResultsFlag flag, StringComparisonMode mode) => CompareImplicitLength(left, right, flag, mode);
/// <summary>
/// int _mm_cmpistra (__m128i a, __m128i b, const int imm8)
/// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8)
/// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static bool CompareImplicitLength(Vector128<byte> left, Vector128<byte> right, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static bool CompareImplicitLength(Vector128<byte> left, Vector128<byte> right, ResultsFlag flag, StringComparisonMode mode) => CompareImplicitLength(left, right, flag, mode);
/// <summary>
/// int _mm_cmpistra (__m128i a, __m128i b, const int imm8)
/// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8)
/// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static bool CompareImplicitLength(Vector128<short> left, Vector128<short> right, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static bool CompareImplicitLength(Vector128<short> left, Vector128<short> right, ResultsFlag flag, StringComparisonMode mode) => CompareImplicitLength(left, right, flag, mode);
/// <summary>
/// int _mm_cmpistrs (__m128i a, __m128i b, const int imm8)
/// int _mm_cmpistrz (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static bool CompareImplicitLength(Vector128<ushort> left, Vector128<ushort> right, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static bool CompareImplicitLength(Vector128<ushort> left, Vector128<ushort> right, ResultsFlag flag, StringComparisonMode mode) => CompareImplicitLength(left, right, flag, mode);
/// <summary>
/// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8)
/// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8)
/// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static bool CompareExplicitLength(Vector128<sbyte> left, byte leftLength, Vector128<sbyte> right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static bool CompareExplicitLength(Vector128<sbyte> left, byte leftLength, Vector128<sbyte> right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) => CompareExplicitLength(left, leftLength, right, rightLength, flag, mode);
/// <summary>
/// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8)
/// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8)
/// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static bool CompareExplicitLength(Vector128<byte> left, byte leftLength, Vector128<byte> right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static bool CompareExplicitLength(Vector128<byte> left, byte leftLength, Vector128<byte> right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) => CompareExplicitLength(left, leftLength, right, rightLength, flag, mode);
/// <summary>
/// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8)
/// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8)
/// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static bool CompareExplicitLength(Vector128<short> left, byte leftLength, Vector128<short> right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static bool CompareExplicitLength(Vector128<short> left, byte leftLength, Vector128<short> right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) => CompareExplicitLength(left, leftLength, right, rightLength, flag, mode);
/// <summary>
/// int _mm_cmpestra (__m128i a, int la, __m128i b, int lb, const int imm8)
/// int _mm_cmpestrs (__m128i a, int la, __m128i b, int lb, const int imm8)
/// int _mm_cmpestrz (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static bool CompareExplicitLength(Vector128<ushort> left, byte leftLength, Vector128<ushort> right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static bool CompareExplicitLength(Vector128<ushort> left, byte leftLength, Vector128<ushort> right, byte rightLength, ResultsFlag flag, StringComparisonMode mode) => CompareExplicitLength(left, leftLength, right, rightLength, flag, mode);
/// <summary>
/// int _mm_cmpistri (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static int CompareImplicitLengthIndex(Vector128<sbyte> left, Vector128<sbyte> right, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static int CompareImplicitLengthIndex(Vector128<sbyte> left, Vector128<sbyte> right, StringComparisonMode mode) => CompareImplicitLengthIndex(left, right, mode);
/// <summary>
/// int _mm_cmpistri (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static int CompareImplicitLengthIndex(Vector128<byte> left, Vector128<byte> right, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static int CompareImplicitLengthIndex(Vector128<byte> left, Vector128<byte> right, StringComparisonMode mode) => CompareImplicitLengthIndex(left, right, mode);
/// <summary>
/// int _mm_cmpistri (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static int CompareImplicitLengthIndex(Vector128<short> left, Vector128<short> right, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static int CompareImplicitLengthIndex(Vector128<short> left, Vector128<short> right, StringComparisonMode mode) => CompareImplicitLengthIndex(left, right, mode);
/// <summary>
/// int _mm_cmpistri (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static int CompareImplicitLengthIndex(Vector128<ushort> left, Vector128<ushort> right, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static int CompareImplicitLengthIndex(Vector128<ushort> left, Vector128<ushort> right, StringComparisonMode mode) => CompareImplicitLengthIndex(left, right, mode);
/// <summary>
/// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static int CompareExplicitLengthIndex(Vector128<sbyte> left, byte leftLength, Vector128<sbyte> right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static int CompareExplicitLengthIndex(Vector128<sbyte> left, byte leftLength, Vector128<sbyte> right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthIndex(left, leftLength, right, rightLength, mode);
/// <summary>
/// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static int CompareExplicitLengthIndex(Vector128<byte> left, byte leftLength, Vector128<byte> right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static int CompareExplicitLengthIndex(Vector128<byte> left, byte leftLength, Vector128<byte> right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthIndex(left, leftLength, right, rightLength, mode);
/// <summary>
/// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static int CompareExplicitLengthIndex(Vector128<short> left, byte leftLength, Vector128<short> right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static int CompareExplicitLengthIndex(Vector128<short> left, byte leftLength, Vector128<short> right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthIndex(left, leftLength, right, rightLength, mode);
/// <summary>
/// int _mm_cmpestri (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static int CompareExplicitLengthIndex(Vector128<ushort> left, byte leftLength, Vector128<ushort> right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static int CompareExplicitLengthIndex(Vector128<ushort> left, byte leftLength, Vector128<ushort> right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthIndex(left, leftLength, right, rightLength, mode);
/// <summary>
/// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<ushort> CompareImplicitLengthBitMask(Vector128<sbyte> left, Vector128<sbyte> right, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<ushort> CompareImplicitLengthBitMask(Vector128<sbyte> left, Vector128<sbyte> right, StringComparisonMode mode) => CompareImplicitLengthBitMask(left, right, mode);
/// <summary>
/// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<ushort> CompareImplicitLengthBitMask(Vector128<byte> left, Vector128<byte> right, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<ushort> CompareImplicitLengthBitMask(Vector128<byte> left, Vector128<byte> right, StringComparisonMode mode) => CompareImplicitLengthBitMask(left, right, mode);
/// <summary>
/// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<byte> CompareImplicitLengthBitMask(Vector128<short> left, Vector128<short> right, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<byte> CompareImplicitLengthBitMask(Vector128<short> left, Vector128<short> right, StringComparisonMode mode) => CompareImplicitLengthBitMask(left, right, mode);
/// <summary>
/// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<byte> CompareImplicitLengthBitMask(Vector128<ushort> left, Vector128<ushort> right, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<byte> CompareImplicitLengthBitMask(Vector128<ushort> left, Vector128<ushort> right, StringComparisonMode mode) => CompareImplicitLengthBitMask(left, right, mode);
/// <summary>
/// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<byte> CompareImplicitLengthUnitMask(Vector128<sbyte> left, Vector128<sbyte> right, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<byte> CompareImplicitLengthUnitMask(Vector128<sbyte> left, Vector128<sbyte> right, StringComparisonMode mode) => CompareImplicitLengthUnitMask(left, right, mode);
/// <summary>
/// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<byte> CompareImplicitLengthUnitMask(Vector128<byte> left, Vector128<byte> right, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<byte> CompareImplicitLengthUnitMask(Vector128<byte> left, Vector128<byte> right, StringComparisonMode mode) => CompareImplicitLengthUnitMask(left, right, mode);
/// <summary>
/// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<ushort> CompareImplicitLengthUnitMask(Vector128<short> left, Vector128<short> right, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<ushort> CompareImplicitLengthUnitMask(Vector128<short> left, Vector128<short> right, StringComparisonMode mode) => CompareImplicitLengthUnitMask(left, right, mode);
/// <summary>
/// __m128i _mm_cmpistrm (__m128i a, __m128i b, const int imm8)
/// </summary>
- public static Vector128<ushort> CompareImplicitLengthUnitMask(Vector128<ushort> left, Vector128<ushort> right, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<ushort> CompareImplicitLengthUnitMask(Vector128<ushort> left, Vector128<ushort> right, StringComparisonMode mode) => CompareImplicitLengthUnitMask(left, right, mode);
/// <summary>
/// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static Vector128<ushort> CompareExplicitLengthBitMask(Vector128<sbyte> left, byte leftLength, Vector128<sbyte> right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<ushort> CompareExplicitLengthBitMask(Vector128<sbyte> left, byte leftLength, Vector128<sbyte> right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthBitMask(left, leftLength, right, rightLength, mode);
/// <summary>
/// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static Vector128<ushort> CompareExplicitLengthBitMask(Vector128<byte> left, byte leftLength, Vector128<byte> right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<ushort> CompareExplicitLengthBitMask(Vector128<byte> left, byte leftLength, Vector128<byte> right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthBitMask(left, leftLength, right, rightLength, mode);
/// <summary>
/// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static Vector128<byte> CompareExplicitLengthBitMask(Vector128<short> left, byte leftLength, Vector128<short> right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<byte> CompareExplicitLengthBitMask(Vector128<short> left, byte leftLength, Vector128<short> right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthBitMask(left, leftLength, right, rightLength, mode);
/// <summary>
/// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static Vector128<byte> CompareExplicitLengthBitMask(Vector128<ushort> left, byte leftLength, Vector128<ushort> right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<byte> CompareExplicitLengthBitMask(Vector128<ushort> left, byte leftLength, Vector128<ushort> right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthBitMask(left, leftLength, right, rightLength, mode);
/// <summary>
/// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static Vector128<byte> CompareExplicitLengthUnitMask(Vector128<sbyte> left, byte leftLength, Vector128<sbyte> right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<byte> CompareExplicitLengthUnitMask(Vector128<sbyte> left, byte leftLength, Vector128<sbyte> right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthUnitMask(left, leftLength, right, rightLength, mode);
/// <summary>
/// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static Vector128<byte> CompareExplicitLengthUnitMask(Vector128<byte> left, byte leftLength, Vector128<byte> right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<byte> CompareExplicitLengthUnitMask(Vector128<byte> left, byte leftLength, Vector128<byte> right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthUnitMask(left, leftLength, right, rightLength, mode);
/// <summary>
/// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static Vector128<ushort> CompareExplicitLengthUnitMask(Vector128<short> left, byte leftLength, Vector128<short> right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<ushort> CompareExplicitLengthUnitMask(Vector128<short> left, byte leftLength, Vector128<short> right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthUnitMask(left, leftLength, right, rightLength, mode);
/// <summary>
/// __m128i _mm_cmpestrm (__m128i a, int la, __m128i b, int lb, const int imm8)
/// </summary>
- public static Vector128<ushort> CompareExplicitLengthUnitMask(Vector128<ushort> left, byte leftLength, Vector128<ushort> right, byte rightLength, StringComparisonMode mode) { throw new NotImplementedException(); }
+ public static Vector128<ushort> CompareExplicitLengthUnitMask(Vector128<ushort> left, byte leftLength, Vector128<ushort> right, byte rightLength, StringComparisonMode mode) => CompareExplicitLengthUnitMask(left, leftLength, right, rightLength, mode);
/// <summary>
/// __m128i _mm_cmpgt_epi64 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<long> CompareGreaterThan(Vector128<long> left, Vector128<long> right) { throw new NotImplementedException(); }
+ public static Vector128<long> CompareGreaterThan(Vector128<long> left, Vector128<long> right) => CompareGreaterThan(left, right);
/// <summary>
/// unsigned int _mm_crc32_u8 (unsigned int crc, unsigned char v)
/// </summary>
- public static uint Crc32(uint crc, byte data) { throw new NotImplementedException(); }
+ public static uint Crc32(uint crc, byte data) => Crc32(crc, data);
/// <summary>
/// unsigned int _mm_crc32_u16 (unsigned int crc, unsigned short v)
/// </summary>
- public static uint Crc32(uint crc, ushort data) { throw new NotImplementedException(); }
+ public static uint Crc32(uint crc, ushort data) => Crc32(crc, data);
/// <summary>
/// unsigned int _mm_crc32_u32 (unsigned int crc, unsigned int v)
/// </summary>
- public static uint Crc32(uint crc, uint data) { throw new NotImplementedException(); }
+ public static uint Crc32(uint crc, uint data) => Crc32(crc, data);
/// <summary>
/// unsigned __int64 _mm_crc32_u64 (unsigned __int64 crc, unsigned __int64 v)
/// </summary>
- public static ulong Crc32(ulong crc, ulong data) { throw new NotImplementedException(); }
+ public static ulong Crc32(ulong crc, ulong data) => Crc32(crc, data);
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.Intrinsics;
+
+namespace System.Runtime.Intrinsics.X86
+{
+ /// <summary>
+ /// This class provides access to Intel SSSE3 hardware instructions via intrinsics
+ /// </summary>
+ [CLSCompliant(false)]
+ public static class Ssse3
+ {
+ public static bool IsSupported { get { return false; } }
+
+ /// <summary>
+ /// __m128i _mm_abs_epi8 (__m128i a)
+ /// </summary>
+ public static Vector128<byte> Abs(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_abs_epi16 (__m128i a)
+ /// </summary>
+ public static Vector128<ushort> Abs(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_abs_epi32 (__m128i a)
+ /// </summary>
+ public static Vector128<uint> Abs(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
+ /// </summary>
+ public static Vector128<sbyte> AlignRight(Vector128<sbyte> left, Vector128<sbyte> right, byte mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_hadd_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> HorizontalAdd(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_hadd_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> HorizontalAdd(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_hadds_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> HorizontalAddSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_hsub_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> HorizontalSubtract(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_hsub_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> HorizontalSubtract(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_hsubs_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> HorizontalSubtractSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_maddubs_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> MultiplyAddAdjacent(Vector128<byte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_mulhrs_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> MultiplyHighRoundScale(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_shuffle_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> Shuffle(Vector128<sbyte> value, Vector128<sbyte> mask) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m128i _mm_sign_epi8 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<sbyte> Sign(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_sign_epi16 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<short> Sign(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m128i _mm_sign_epi32 (__m128i a, __m128i b)
+ /// </summary>
+ public static Vector128<int> Sign(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ }
+}
[CLSCompliant(false)]
public static class Ssse3
{
- public static bool IsSupported { get { return false; } }
+ public static bool IsSupported { get => IsSupported; }
/// <summary>
/// __m128i _mm_abs_epi8 (__m128i a)
/// </summary>
- public static Vector128<byte> Abs(Vector128<sbyte> value) { throw new NotImplementedException(); }
+ public static Vector128<byte> Abs(Vector128<sbyte> value) => Abs(value);
/// <summary>
/// __m128i _mm_abs_epi16 (__m128i a)
/// </summary>
- public static Vector128<ushort> Abs(Vector128<short> value) { throw new NotImplementedException(); }
+ public static Vector128<ushort> Abs(Vector128<short> value) => Abs(value);
/// <summary>
/// __m128i _mm_abs_epi32 (__m128i a)
/// </summary>
- public static Vector128<uint> Abs(Vector128<int> value) { throw new NotImplementedException(); }
+ public static Vector128<uint> Abs(Vector128<int> value) => Abs(value);
/// <summary>
/// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
/// </summary>
- public static Vector128<sbyte> AlignRight(Vector128<sbyte> left, Vector128<sbyte> right, byte mask) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> AlignRight(Vector128<sbyte> left, Vector128<sbyte> right, byte mask) => AlignRight(left, right, mask);
/// <summary>
/// __m128i _mm_hadd_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> HorizontalAdd(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> HorizontalAdd(Vector128<short> left, Vector128<short> right) => HorizontalAdd(left, right);
/// <summary>
/// __m128i _mm_hadd_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> HorizontalAdd(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> HorizontalAdd(Vector128<int> left, Vector128<int> right) => HorizontalAdd(left, right);
/// <summary>
/// __m128i _mm_hadds_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> HorizontalAddSaturate(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> HorizontalAddSaturate(Vector128<short> left, Vector128<short> right) => HorizontalAddSaturate(left, right);
/// <summary>
/// __m128i _mm_hsub_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> HorizontalSubtract(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> HorizontalSubtract(Vector128<short> left, Vector128<short> right) => HorizontalSubtract(left, right);
/// <summary>
/// __m128i _mm_hsub_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> HorizontalSubtract(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> HorizontalSubtract(Vector128<int> left, Vector128<int> right) => HorizontalSubtract(left, right);
/// <summary>
/// __m128i _mm_hsubs_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> HorizontalSubtractSaturate(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> HorizontalSubtractSaturate(Vector128<short> left, Vector128<short> right) => HorizontalSubtractSaturate(left, right);
/// <summary>
/// __m128i _mm_maddubs_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> MultiplyAddAdjacent(Vector128<byte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<short> MultiplyAddAdjacent(Vector128<byte> left, Vector128<sbyte> right) => MultiplyAddAdjacent(left, right);
/// <summary>
/// __m128i _mm_mulhrs_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> MultiplyHighRoundScale(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> MultiplyHighRoundScale(Vector128<short> left, Vector128<short> right) => MultiplyHighRoundScale(left, right);
/// <summary>
/// __m128i _mm_shuffle_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> Shuffle(Vector128<sbyte> value, Vector128<sbyte> mask) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> Shuffle(Vector128<sbyte> value, Vector128<sbyte> mask) => Shuffle(value, mask);
/// <summary>
/// __m128i _mm_sign_epi8 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<sbyte> Sign(Vector128<sbyte> left, Vector128<sbyte> right) { throw new NotImplementedException(); }
+ public static Vector128<sbyte> Sign(Vector128<sbyte> left, Vector128<sbyte> right) => Sign(left, right);
/// <summary>
/// __m128i _mm_sign_epi16 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<short> Sign(Vector128<short> left, Vector128<short> right) { throw new NotImplementedException(); }
+ public static Vector128<short> Sign(Vector128<short> left, Vector128<short> right) => Sign(left, right);
/// <summary>
/// __m128i _mm_sign_epi32 (__m128i a, __m128i b)
/// </summary>
- public static Vector128<int> Sign(Vector128<int> left, Vector128<int> right) { throw new NotImplementedException(); }
+ public static Vector128<int> Sign(Vector128<int> left, Vector128<int> right) => Sign(left, right);
}
}
projects / platform / upstream / coreclr.git / commitdiff