* Rename AddReturning{Rounded}HighNarrow to Add{Rounded}HighNarrow in AdvSimd.PlatformNotSupported.cs AdvSimd.cs
* Rename SubtractReturning{Rounded}HighNarrow to Subtract{Rounded}HighNarrow in AdvSimd.PlatformNotSupported.cs AdvSimd.cs
* Rename Add/SubtractReturning{Rounded}HighNarrow to Add/Subtract{Rounded}HighNarrow in hwintrinsiclistarm64.h
* Update System.Runtime.Intrinsics.Experimental.cs
* Rename Add/SubtractReturning{Rounded}HighNarrow to Add/Subtract{Rounded}HighNarrow in GenerateTests.csx
* Update Helpers.cs Helpers.tt
* Update AdvSimd/
HARDWARE_INTRINSIC(AdvSimd, AbsoluteDifferenceWideningUpper, 16, 2, {INS_sabdl2, INS_uabdl2, INS_sabdl2, INS_uabdl2, INS_sabdl2, INS_uabdl2, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_BaseTypeFromFirstArg)
HARDWARE_INTRINSIC(AdvSimd, AbsoluteDifferenceWideningUpperAndAdd, 16, 3, {INS_sabal2, INS_uabal2, INS_sabal2, INS_uabal2, INS_sabal2, INS_uabal2, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_HasRMWSemantics|HW_Flag_BaseTypeFromSecondArg)
HARDWARE_INTRINSIC(AdvSimd, Add, -1, 2, {INS_add, INS_add, INS_add, INS_add, INS_add, INS_add, INS_add, INS_add, INS_fadd, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
+HARDWARE_INTRINSIC(AdvSimd, AddHighNarrowLower, 8, 2, {INS_addhn, INS_addhn, INS_addhn, INS_addhn, INS_addhn, INS_addhn, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
+HARDWARE_INTRINSIC(AdvSimd, AddHighNarrowUpper, 16, 3, {INS_addhn2, INS_addhn2, INS_addhn2, INS_addhn2, INS_addhn2, INS_addhn2, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_HasRMWSemantics)
HARDWARE_INTRINSIC(AdvSimd, AddPairwise, 8, 2, {INS_addp, INS_addp, INS_addp, INS_addp, INS_addp, INS_addp, INS_invalid, INS_invalid, INS_faddp, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
HARDWARE_INTRINSIC(AdvSimd, AddPairwiseWidening, -1, 1, {INS_saddlp, INS_uaddlp, INS_saddlp, INS_uaddlp, INS_saddlp, INS_uaddlp, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg)
HARDWARE_INTRINSIC(AdvSimd, AddPairwiseWideningAndAdd, -1, 2, {INS_sadalp, INS_uadalp, INS_sadalp, INS_uadalp, INS_sadalp, INS_uadalp, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_HasRMWSemantics|HW_Flag_BaseTypeFromSecondArg)
HARDWARE_INTRINSIC(AdvSimd, AddPairwiseWideningAndAddScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sadalp, INS_uadalp, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_HasRMWSemantics|HW_Flag_BaseTypeFromSecondArg)
HARDWARE_INTRINSIC(AdvSimd, AddPairwiseWideningScalar, 8, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_saddlp, INS_uaddlp, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg)
-HARDWARE_INTRINSIC(AdvSimd, AddReturningHighNarrowLower, 8, 2, {INS_addhn, INS_addhn, INS_addhn, INS_addhn, INS_addhn, INS_addhn, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
-HARDWARE_INTRINSIC(AdvSimd, AddReturningHighNarrowUpper, 16, 3, {INS_addhn2, INS_addhn2, INS_addhn2, INS_addhn2, INS_addhn2, INS_addhn2, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_HasRMWSemantics)
-HARDWARE_INTRINSIC(AdvSimd, AddReturningRoundedHighNarrowLower, 8, 2, {INS_raddhn, INS_raddhn, INS_raddhn, INS_raddhn, INS_raddhn, INS_raddhn, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
-HARDWARE_INTRINSIC(AdvSimd, AddReturningRoundedHighNarrowUpper, 16, 3, {INS_raddhn2, INS_raddhn2, INS_raddhn2, INS_raddhn2, INS_raddhn2, INS_raddhn2, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_HasRMWSemantics)
+HARDWARE_INTRINSIC(AdvSimd, AddRoundedHighNarrowLower, 8, 2, {INS_raddhn, INS_raddhn, INS_raddhn, INS_raddhn, INS_raddhn, INS_raddhn, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
+HARDWARE_INTRINSIC(AdvSimd, AddRoundedHighNarrowUpper, 16, 3, {INS_raddhn2, INS_raddhn2, INS_raddhn2, INS_raddhn2, INS_raddhn2, INS_raddhn2, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_HasRMWSemantics)
HARDWARE_INTRINSIC(AdvSimd, AddSaturate, -1, 2, {INS_sqadd, INS_uqadd, INS_sqadd, INS_uqadd, INS_sqadd, INS_uqadd, INS_sqadd, INS_uqadd, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
HARDWARE_INTRINSIC(AdvSimd, AddSaturateScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sqadd, INS_uqadd, INS_invalid, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_Commutative)
HARDWARE_INTRINSIC(AdvSimd, AddScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_add, INS_add, INS_fadd, INS_fadd}, HW_Category_SIMDScalar, HW_Flag_Commutative)
HARDWARE_INTRINSIC(AdvSimd, SqrtScalar, 8, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_fsqrt, INS_fsqrt}, HW_Category_SIMDScalar, HW_Flag_NoFlag)
HARDWARE_INTRINSIC(AdvSimd, Store, -1, 2, {INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1}, HW_Category_MemoryStore, HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromSecondArg)
HARDWARE_INTRINSIC(AdvSimd, Subtract, -1, 2, {INS_sub, INS_sub, INS_sub, INS_sub, INS_sub, INS_sub, INS_sub, INS_sub, INS_fsub, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(AdvSimd, SubtractReturningHighNarrowLower, 8, 2, {INS_subhn, INS_subhn, INS_subhn, INS_subhn, INS_subhn, INS_subhn, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(AdvSimd, SubtractReturningHighNarrowUpper, 16, 3, {INS_subhn2, INS_subhn2, INS_subhn2, INS_subhn2, INS_subhn2, INS_subhn2, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_HasRMWSemantics)
-HARDWARE_INTRINSIC(AdvSimd, SubtractReturningRoundedHighNarrowLower, 8, 2, {INS_rsubhn, INS_rsubhn, INS_rsubhn, INS_rsubhn, INS_rsubhn, INS_rsubhn, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(AdvSimd, SubtractReturningRoundedHighNarrowUpper, 16, 3, {INS_rsubhn2, INS_rsubhn2, INS_rsubhn2, INS_rsubhn2, INS_rsubhn2, INS_rsubhn2, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_HasRMWSemantics)
+HARDWARE_INTRINSIC(AdvSimd, SubtractHighNarrowLower, 8, 2, {INS_subhn, INS_subhn, INS_subhn, INS_subhn, INS_subhn, INS_subhn, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
+HARDWARE_INTRINSIC(AdvSimd, SubtractHighNarrowUpper, 16, 3, {INS_subhn2, INS_subhn2, INS_subhn2, INS_subhn2, INS_subhn2, INS_subhn2, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_HasRMWSemantics)
+HARDWARE_INTRINSIC(AdvSimd, SubtractRoundedHighNarrowLower, 8, 2, {INS_rsubhn, INS_rsubhn, INS_rsubhn, INS_rsubhn, INS_rsubhn, INS_rsubhn, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
+HARDWARE_INTRINSIC(AdvSimd, SubtractRoundedHighNarrowUpper, 16, 3, {INS_rsubhn2, INS_rsubhn2, INS_rsubhn2, INS_rsubhn2, INS_rsubhn2, INS_rsubhn2, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_HasRMWSemantics)
HARDWARE_INTRINSIC(AdvSimd, SubtractSaturate, -1, 2, {INS_sqsub, INS_uqsub, INS_sqsub, INS_uqsub, INS_sqsub, INS_uqsub, INS_sqsub, INS_uqsub, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
HARDWARE_INTRINSIC(AdvSimd, SubtractSaturateScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sqsub, INS_uqsub, INS_invalid, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_NoFlag)
HARDWARE_INTRINSIC(AdvSimd, SubtractScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sub, INS_sub, INS_fsub, INS_fsub}, HW_Category_SIMDScalar, HW_Flag_NoFlag)
{
public static partial class Program
{
- private static void SubtractReturningRoundedHighNarrowLower_Vector64_Byte()
+ private static void AddHighNarrowLower_Vector64_Byte()
{
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Byte();
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Byte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Byte
+ public sealed unsafe class SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Byte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Byte testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Byte testClass)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Byte testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Byte testClass)
{
fixed (Vector128<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Byte()
+ static SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Byte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar2), ref Unsafe.As<UInt16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
- public SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Byte()
+ public SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Byte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<UInt16>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt16>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pClsVar1)),
AdvSimd.LoadVector128((UInt16*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Byte();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Byte();
+ var result = AdvSimd.AddHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Byte();
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Byte();
fixed (Vector128<UInt16>* pFld1 = &test._fld1)
fixed (Vector128<UInt16>* pFld2 = &test._fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.AddHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(&test._fld1)),
AdvSimd.LoadVector128((UInt16*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningRoundedHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.AddHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower)}<Byte>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddHighNarrowLower)}<Byte>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void SubtractReturningRoundedHighNarrowLower_Vector64_Int16()
+ private static void AddHighNarrowLower_Vector64_Int16()
{
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int16();
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int16
+ public sealed unsafe class SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int16 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int16 testClass)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int16 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int16 testClass)
{
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int16()
+ static SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar2), ref Unsafe.As<Int32, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
}
- public SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int16()
+ public SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<Int32>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int32>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pClsVar1)),
AdvSimd.LoadVector128((Int32*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int16();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int16();
+ var result = AdvSimd.AddHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int16();
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int16();
fixed (Vector128<Int32>* pFld1 = &test._fld1)
fixed (Vector128<Int32>* pFld2 = &test._fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.AddHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(&test._fld1)),
AdvSimd.LoadVector128((Int32*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningRoundedHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.AddHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower)}<Int16>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddHighNarrowLower)}<Int16>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void SubtractReturningRoundedHighNarrowLower_Vector64_Int32()
+ private static void AddHighNarrowLower_Vector64_Int32()
{
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int32();
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int32
+ public sealed unsafe class SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int32 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int32 testClass)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int32 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int32 testClass)
{
fixed (Vector128<Int64>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int32()
+ static SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar1), ref Unsafe.As<Int64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar2), ref Unsafe.As<Int64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
}
- public SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int32()
+ public SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<Int64>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pClsVar1)),
AdvSimd.LoadVector128((Int64*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int32();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int32();
+ var result = AdvSimd.AddHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_Int32();
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_Int32();
fixed (Vector128<Int64>* pFld1 = &test._fld1)
fixed (Vector128<Int64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Int64>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.AddHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(&test._fld1)),
AdvSimd.LoadVector128((Int64*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningRoundedHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.AddHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower)}<Int32>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddHighNarrowLower)}<Int32>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void SubtractReturningRoundedHighNarrowLower_Vector64_SByte()
+ private static void AddHighNarrowLower_Vector64_SByte()
{
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_SByte();
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_SByte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_SByte
+ public sealed unsafe class SimpleBinaryOpTest__AddHighNarrowLower_Vector64_SByte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_SByte testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__AddHighNarrowLower_Vector64_SByte testClass)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_SByte testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddHighNarrowLower_Vector64_SByte testClass)
{
fixed (Vector128<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_SByte()
+ static SimpleBinaryOpTest__AddHighNarrowLower_Vector64_SByte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar1), ref Unsafe.As<Int16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar2), ref Unsafe.As<Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
}
- public SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_SByte()
+ public SimpleBinaryOpTest__AddHighNarrowLower_Vector64_SByte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<Int16>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int16>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pClsVar1)),
AdvSimd.LoadVector128((Int16*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_SByte();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_SByte();
+ var result = AdvSimd.AddHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_SByte();
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_SByte();
fixed (Vector128<Int16>* pFld1 = &test._fld1)
fixed (Vector128<Int16>* pFld2 = &test._fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.AddHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(&test._fld1)),
AdvSimd.LoadVector128((Int16*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningRoundedHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.AddHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower)}<SByte>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddHighNarrowLower)}<SByte>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void SubtractReturningRoundedHighNarrowLower_Vector64_UInt16()
+ private static void AddHighNarrowLower_Vector64_UInt16()
{
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt16();
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt16
+ public sealed unsafe class SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt16 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt16 testClass)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt16 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt16 testClass)
{
fixed (Vector128<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt16()
+ static SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar1), ref Unsafe.As<UInt32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar2), ref Unsafe.As<UInt32, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
}
- public SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt16()
+ public SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<UInt32>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt32>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pClsVar1)),
AdvSimd.LoadVector128((UInt32*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt16();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt16();
+ var result = AdvSimd.AddHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt16();
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt16();
fixed (Vector128<UInt32>* pFld1 = &test._fld1)
fixed (Vector128<UInt32>* pFld2 = &test._fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.AddHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(&test._fld1)),
AdvSimd.LoadVector128((UInt32*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningRoundedHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.AddHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower)}<UInt16>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddHighNarrowLower)}<UInt16>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void SubtractReturningRoundedHighNarrowLower_Vector64_UInt32()
+ private static void AddHighNarrowLower_Vector64_UInt32()
{
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt32();
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt32
+ public sealed unsafe class SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt32 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt32 testClass)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt32 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt32 testClass)
{
fixed (Vector128<UInt64>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt32()
+ static SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar1), ref Unsafe.As<UInt64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar2), ref Unsafe.As<UInt64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
}
- public SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt32()
+ public SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<UInt64>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pClsVar1)),
AdvSimd.LoadVector128((UInt64*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt32();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt32();
+ var result = AdvSimd.AddHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__SubtractReturningRoundedHighNarrowLower_Vector64_UInt32();
+ var test = new SimpleBinaryOpTest__AddHighNarrowLower_Vector64_UInt32();
fixed (Vector128<UInt64>* pFld1 = &test._fld1)
fixed (Vector128<UInt64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<UInt64>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.AddHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowLower(
+ var result = AdvSimd.AddHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(&test._fld1)),
AdvSimd.LoadVector128((UInt64*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningRoundedHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.AddHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningRoundedHighNarrowLower)}<UInt32>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddHighNarrowLower)}<UInt32>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void SubtractReturningHighNarrowUpper_Vector128_Byte()
+ private static void AddHighNarrowUpper_Vector128_Byte()
{
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Byte();
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Byte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Byte
+ public sealed unsafe class SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Byte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Byte testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Byte testClass)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Byte testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Byte testClass)
{
fixed (Vector64<Byte>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
fixed (Vector128<UInt16>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
AdvSimd.LoadVector128((UInt16*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Byte()
+ static SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Byte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _clsVar1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar3), ref Unsafe.As<UInt16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
- public SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Byte()
+ public SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Byte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<UInt16>* pClsVar2 = &_clsVar2)
fixed (Vector128<UInt16>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pClsVar1)),
AdvSimd.LoadVector128((UInt16*)(pClsVar2)),
AdvSimd.LoadVector128((UInt16*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.SubtractReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Byte();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Byte();
+ var result = AdvSimd.AddHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Byte();
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Byte();
fixed (Vector64<Byte>* pFld1 = &test._fld1)
fixed (Vector128<UInt16>* pFld2 = &test._fld2)
fixed (Vector128<UInt16>* pFld3 = &test._fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
AdvSimd.LoadVector128((UInt16*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<UInt16>* pFld2 = &_fld2)
fixed (Vector128<UInt16>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
AdvSimd.LoadVector128((UInt16*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.AddHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(&test._fld1)),
AdvSimd.LoadVector128((UInt16*)(&test._fld2)),
AdvSimd.LoadVector128((UInt16*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.AddHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningHighNarrowUpper)}<Byte>(Vector64<Byte>, Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddHighNarrowUpper)}<Byte>(Vector64<Byte>, Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void AddReturningRoundedHighNarrowUpper_Vector128_Int16()
+ private static void AddHighNarrowUpper_Vector128_Int16()
{
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int16();
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int16
+ public sealed unsafe class SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int16 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int16 testClass)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int16 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int16 testClass)
{
fixed (Vector64<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
fixed (Vector128<Int32>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
AdvSimd.LoadVector128((Int32*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int16()
+ static SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _clsVar1), ref Unsafe.As<Int16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar3), ref Unsafe.As<Int32, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
}
- public SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int16()
+ public SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<Int32>* pClsVar2 = &_clsVar2)
fixed (Vector128<Int32>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pClsVar1)),
AdvSimd.LoadVector128((Int32*)(pClsVar2)),
AdvSimd.LoadVector128((Int32*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int16();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int16();
+ var result = AdvSimd.AddHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int16();
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int16();
fixed (Vector64<Int16>* pFld1 = &test._fld1)
fixed (Vector128<Int32>* pFld2 = &test._fld2)
fixed (Vector128<Int32>* pFld3 = &test._fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
AdvSimd.LoadVector128((Int32*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<Int32>* pFld2 = &_fld2)
fixed (Vector128<Int32>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
AdvSimd.LoadVector128((Int32*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.AddHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(&test._fld1)),
AdvSimd.LoadVector128((Int32*)(&test._fld2)),
AdvSimd.LoadVector128((Int32*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.AddHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningRoundedHighNarrowUpper)}<Int16>(Vector64<Int16>, Vector128<Int32>, Vector128<Int32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddHighNarrowUpper)}<Int16>(Vector64<Int16>, Vector128<Int32>, Vector128<Int32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void AddReturningRoundedHighNarrowUpper_Vector128_Int32()
+ private static void AddHighNarrowUpper_Vector128_Int32()
{
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int32();
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int32
+ public sealed unsafe class SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int32 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int32 testClass)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int32 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int32 testClass)
{
fixed (Vector64<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
fixed (Vector128<Int64>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
AdvSimd.LoadVector128((Int64*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int32()
+ static SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int32>, byte>(ref _clsVar1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Int32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar3), ref Unsafe.As<Int64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
}
- public SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int32()
+ public SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<Int64>* pClsVar2 = &_clsVar2)
fixed (Vector128<Int64>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pClsVar1)),
AdvSimd.LoadVector128((Int64*)(pClsVar2)),
AdvSimd.LoadVector128((Int64*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int32();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int32();
+ var result = AdvSimd.AddHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Int32();
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_Int32();
fixed (Vector64<Int32>* pFld1 = &test._fld1)
fixed (Vector128<Int64>* pFld2 = &test._fld2)
fixed (Vector128<Int64>* pFld3 = &test._fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
AdvSimd.LoadVector128((Int64*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<Int64>* pFld2 = &_fld2)
fixed (Vector128<Int64>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
AdvSimd.LoadVector128((Int64*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.AddHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(&test._fld1)),
AdvSimd.LoadVector128((Int64*)(&test._fld2)),
AdvSimd.LoadVector128((Int64*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.AddHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningRoundedHighNarrowUpper)}<Int32>(Vector64<Int32>, Vector128<Int64>, Vector128<Int64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddHighNarrowUpper)}<Int32>(Vector64<Int32>, Vector128<Int64>, Vector128<Int64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void AddReturningRoundedHighNarrowUpper_Vector128_SByte()
+ private static void AddHighNarrowUpper_Vector128_SByte()
{
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_SByte();
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_SByte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_SByte
+ public sealed unsafe class SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_SByte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_SByte testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_SByte testClass)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_SByte testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_SByte testClass)
{
fixed (Vector64<SByte>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
fixed (Vector128<Int16>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
AdvSimd.LoadVector128((Int16*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_SByte()
+ static SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_SByte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<SByte>, byte>(ref _clsVar1), ref Unsafe.As<SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<SByte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar3), ref Unsafe.As<Int16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
}
- public SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_SByte()
+ public SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_SByte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<Int16>* pClsVar2 = &_clsVar2)
fixed (Vector128<Int16>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pClsVar1)),
AdvSimd.LoadVector128((Int16*)(pClsVar2)),
AdvSimd.LoadVector128((Int16*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_SByte();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_SByte();
+ var result = AdvSimd.AddHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_SByte();
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_SByte();
fixed (Vector64<SByte>* pFld1 = &test._fld1)
fixed (Vector128<Int16>* pFld2 = &test._fld2)
fixed (Vector128<Int16>* pFld3 = &test._fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
AdvSimd.LoadVector128((Int16*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<Int16>* pFld2 = &_fld2)
fixed (Vector128<Int16>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
AdvSimd.LoadVector128((Int16*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.AddHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(&test._fld1)),
AdvSimd.LoadVector128((Int16*)(&test._fld2)),
AdvSimd.LoadVector128((Int16*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.AddHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningRoundedHighNarrowUpper)}<SByte>(Vector64<SByte>, Vector128<Int16>, Vector128<Int16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddHighNarrowUpper)}<SByte>(Vector64<SByte>, Vector128<Int16>, Vector128<Int16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void SubtractReturningHighNarrowUpper_Vector128_UInt16()
+ private static void AddHighNarrowUpper_Vector128_UInt16()
{
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt16();
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt16
+ public sealed unsafe class SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt16 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt16 testClass)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt16 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt16 testClass)
{
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
fixed (Vector128<UInt32>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
AdvSimd.LoadVector128((UInt32*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt16()
+ static SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar3), ref Unsafe.As<UInt32, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
}
- public SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt16()
+ public SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<UInt32>* pClsVar2 = &_clsVar2)
fixed (Vector128<UInt32>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pClsVar1)),
AdvSimd.LoadVector128((UInt32*)(pClsVar2)),
AdvSimd.LoadVector128((UInt32*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.SubtractReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt16();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt16();
+ var result = AdvSimd.AddHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt16();
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt16();
fixed (Vector64<UInt16>* pFld1 = &test._fld1)
fixed (Vector128<UInt32>* pFld2 = &test._fld2)
fixed (Vector128<UInt32>* pFld3 = &test._fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
AdvSimd.LoadVector128((UInt32*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<UInt32>* pFld2 = &_fld2)
fixed (Vector128<UInt32>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
AdvSimd.LoadVector128((UInt32*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.AddHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(&test._fld1)),
AdvSimd.LoadVector128((UInt32*)(&test._fld2)),
AdvSimd.LoadVector128((UInt32*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.AddHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningHighNarrowUpper)}<UInt16>(Vector64<UInt16>, Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddHighNarrowUpper)}<UInt16>(Vector64<UInt16>, Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void SubtractReturningHighNarrowUpper_Vector128_UInt32()
+ private static void AddHighNarrowUpper_Vector128_UInt32()
{
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt32();
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt32
+ public sealed unsafe class SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt32 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt32 testClass)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt32 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt32 testClass)
{
fixed (Vector64<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
fixed (Vector128<UInt64>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
AdvSimd.LoadVector128((UInt64*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt32()
+ static SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt32>, byte>(ref _clsVar1), ref Unsafe.As<UInt32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar3), ref Unsafe.As<UInt64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
}
- public SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt32()
+ public SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<UInt64>* pClsVar2 = &_clsVar2)
fixed (Vector128<UInt64>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pClsVar1)),
AdvSimd.LoadVector128((UInt64*)(pClsVar2)),
AdvSimd.LoadVector128((UInt64*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.SubtractReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt32();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt32();
+ var result = AdvSimd.AddHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_UInt32();
+ var test = new SimpleTernaryOpTest__AddHighNarrowUpper_Vector128_UInt32();
fixed (Vector64<UInt32>* pFld1 = &test._fld1)
fixed (Vector128<UInt64>* pFld2 = &test._fld2)
fixed (Vector128<UInt64>* pFld3 = &test._fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
AdvSimd.LoadVector128((UInt64*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<UInt64>* pFld2 = &_fld2)
fixed (Vector128<UInt64>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
AdvSimd.LoadVector128((UInt64*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.AddHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.AddHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(&test._fld1)),
AdvSimd.LoadVector128((UInt64*)(&test._fld2)),
AdvSimd.LoadVector128((UInt64*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.AddHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningHighNarrowUpper)}<UInt32>(Vector64<UInt32>, Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddHighNarrowUpper)}<UInt32>(Vector64<UInt32>, Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void SubtractReturningHighNarrowLower_Vector64_Byte()
+ private static void AddRoundedHighNarrowLower_Vector64_Byte()
{
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Byte();
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Byte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Byte
+ public sealed unsafe class SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Byte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Byte testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Byte testClass)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Byte testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Byte testClass)
{
fixed (Vector128<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Byte()
+ static SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Byte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar2), ref Unsafe.As<UInt16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
- public SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Byte()
+ public SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Byte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<UInt16>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt16>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pClsVar1)),
AdvSimd.LoadVector128((UInt16*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.SubtractReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.SubtractReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Byte();
- var result = AdvSimd.SubtractReturningHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Byte();
+ var result = AdvSimd.AddRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Byte();
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Byte();
fixed (Vector128<UInt16>* pFld1 = &test._fld1)
fixed (Vector128<UInt16>* pFld2 = &test._fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(&test._fld1)),
AdvSimd.LoadVector128((UInt16*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.AddRoundedHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningHighNarrowLower)}<Byte>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddRoundedHighNarrowLower)}<Byte>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void SubtractReturningHighNarrowLower_Vector64_Int16()
+ private static void AddRoundedHighNarrowLower_Vector64_Int16()
{
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int16();
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int16
+ public sealed unsafe class SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int16 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int16 testClass)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int16 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int16 testClass)
{
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int16()
+ static SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar2), ref Unsafe.As<Int32, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
}
- public SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int16()
+ public SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<Int32>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int32>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pClsVar1)),
AdvSimd.LoadVector128((Int32*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.SubtractReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.SubtractReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int16();
- var result = AdvSimd.SubtractReturningHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int16();
+ var result = AdvSimd.AddRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int16();
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int16();
fixed (Vector128<Int32>* pFld1 = &test._fld1)
fixed (Vector128<Int32>* pFld2 = &test._fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(&test._fld1)),
AdvSimd.LoadVector128((Int32*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.AddRoundedHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningHighNarrowLower)}<Int16>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddRoundedHighNarrowLower)}<Int16>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void SubtractReturningHighNarrowLower_Vector64_Int32()
+ private static void AddRoundedHighNarrowLower_Vector64_Int32()
{
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int32();
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int32
+ public sealed unsafe class SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int32 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int32 testClass)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int32 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int32 testClass)
{
fixed (Vector128<Int64>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int32()
+ static SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar1), ref Unsafe.As<Int64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar2), ref Unsafe.As<Int64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
}
- public SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int32()
+ public SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<Int64>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pClsVar1)),
AdvSimd.LoadVector128((Int64*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.SubtractReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.SubtractReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int32();
- var result = AdvSimd.SubtractReturningHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int32();
+ var result = AdvSimd.AddRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_Int32();
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_Int32();
fixed (Vector128<Int64>* pFld1 = &test._fld1)
fixed (Vector128<Int64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Int64>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(&test._fld1)),
AdvSimd.LoadVector128((Int64*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.AddRoundedHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningHighNarrowLower)}<Int32>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddRoundedHighNarrowLower)}<Int32>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void SubtractReturningHighNarrowLower_Vector64_SByte()
+ private static void AddRoundedHighNarrowLower_Vector64_SByte()
{
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_SByte();
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_SByte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_SByte
+ public sealed unsafe class SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_SByte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_SByte testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_SByte testClass)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_SByte testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_SByte testClass)
{
fixed (Vector128<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_SByte()
+ static SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_SByte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar1), ref Unsafe.As<Int16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar2), ref Unsafe.As<Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
}
- public SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_SByte()
+ public SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_SByte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<Int16>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int16>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pClsVar1)),
AdvSimd.LoadVector128((Int16*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.SubtractReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.SubtractReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_SByte();
- var result = AdvSimd.SubtractReturningHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_SByte();
+ var result = AdvSimd.AddRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_SByte();
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_SByte();
fixed (Vector128<Int16>* pFld1 = &test._fld1)
fixed (Vector128<Int16>* pFld2 = &test._fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(&test._fld1)),
AdvSimd.LoadVector128((Int16*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.AddRoundedHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningHighNarrowLower)}<SByte>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddRoundedHighNarrowLower)}<SByte>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void SubtractReturningHighNarrowLower_Vector64_UInt16()
+ private static void AddRoundedHighNarrowLower_Vector64_UInt16()
{
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt16();
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt16
+ public sealed unsafe class SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt16 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt16 testClass)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt16 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt16 testClass)
{
fixed (Vector128<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt16()
+ static SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar1), ref Unsafe.As<UInt32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar2), ref Unsafe.As<UInt32, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
}
- public SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt16()
+ public SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<UInt32>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt32>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pClsVar1)),
AdvSimd.LoadVector128((UInt32*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.SubtractReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.SubtractReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt16();
- var result = AdvSimd.SubtractReturningHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt16();
+ var result = AdvSimd.AddRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt16();
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt16();
fixed (Vector128<UInt32>* pFld1 = &test._fld1)
fixed (Vector128<UInt32>* pFld2 = &test._fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(&test._fld1)),
AdvSimd.LoadVector128((UInt32*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.AddRoundedHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningHighNarrowLower)}<UInt16>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddRoundedHighNarrowLower)}<UInt16>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void SubtractReturningHighNarrowLower_Vector64_UInt32()
+ private static void AddRoundedHighNarrowLower_Vector64_UInt32()
{
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt32();
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt32
+ public sealed unsafe class SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt32 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt32 testClass)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt32 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt32 testClass)
{
fixed (Vector128<UInt64>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt32()
+ static SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar1), ref Unsafe.As<UInt64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar2), ref Unsafe.As<UInt64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
}
- public SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt32()
+ public SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<UInt64>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pClsVar1)),
AdvSimd.LoadVector128((UInt64*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.SubtractReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.SubtractReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt32();
- var result = AdvSimd.SubtractReturningHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt32();
+ var result = AdvSimd.AddRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__SubtractReturningHighNarrowLower_Vector64_UInt32();
+ var test = new SimpleBinaryOpTest__AddRoundedHighNarrowLower_Vector64_UInt32();
fixed (Vector128<UInt64>* pFld1 = &test._fld1)
fixed (Vector128<UInt64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<UInt64>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.AddRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowLower(
+ var result = AdvSimd.AddRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(&test._fld1)),
AdvSimd.LoadVector128((UInt64*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.AddRoundedHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningHighNarrowLower)}<UInt32>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddRoundedHighNarrowLower)}<UInt32>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void SubtractReturningRoundedHighNarrowUpper_Vector128_Byte()
+ private static void AddRoundedHighNarrowUpper_Vector128_Byte()
{
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Byte();
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Byte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Byte
+ public sealed unsafe class SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Byte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Byte testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Byte testClass)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Byte testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Byte testClass)
{
fixed (Vector64<Byte>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
fixed (Vector128<UInt16>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
AdvSimd.LoadVector128((UInt16*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Byte()
+ static SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Byte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _clsVar1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar3), ref Unsafe.As<UInt16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
- public SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Byte()
+ public SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Byte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<UInt16>* pClsVar2 = &_clsVar2)
fixed (Vector128<UInt16>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pClsVar1)),
AdvSimd.LoadVector128((UInt16*)(pClsVar2)),
AdvSimd.LoadVector128((UInt16*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Byte();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Byte();
+ var result = AdvSimd.AddRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Byte();
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Byte();
fixed (Vector64<Byte>* pFld1 = &test._fld1)
fixed (Vector128<UInt16>* pFld2 = &test._fld2)
fixed (Vector128<UInt16>* pFld3 = &test._fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
AdvSimd.LoadVector128((UInt16*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<UInt16>* pFld2 = &_fld2)
fixed (Vector128<UInt16>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
AdvSimd.LoadVector128((UInt16*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(&test._fld1)),
AdvSimd.LoadVector128((UInt16*)(&test._fld2)),
AdvSimd.LoadVector128((UInt16*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.AddRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper)}<Byte>(Vector64<Byte>, Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddRoundedHighNarrowUpper)}<Byte>(Vector64<Byte>, Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void SubtractReturningRoundedHighNarrowUpper_Vector128_Int16()
+ private static void AddRoundedHighNarrowUpper_Vector128_Int16()
{
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int16();
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int16
+ public sealed unsafe class SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int16 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int16 testClass)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int16 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int16 testClass)
{
fixed (Vector64<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
fixed (Vector128<Int32>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
AdvSimd.LoadVector128((Int32*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int16()
+ static SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _clsVar1), ref Unsafe.As<Int16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar3), ref Unsafe.As<Int32, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
}
- public SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int16()
+ public SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<Int32>* pClsVar2 = &_clsVar2)
fixed (Vector128<Int32>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pClsVar1)),
AdvSimd.LoadVector128((Int32*)(pClsVar2)),
AdvSimd.LoadVector128((Int32*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int16();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int16();
+ var result = AdvSimd.AddRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int16();
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int16();
fixed (Vector64<Int16>* pFld1 = &test._fld1)
fixed (Vector128<Int32>* pFld2 = &test._fld2)
fixed (Vector128<Int32>* pFld3 = &test._fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
AdvSimd.LoadVector128((Int32*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<Int32>* pFld2 = &_fld2)
fixed (Vector128<Int32>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
AdvSimd.LoadVector128((Int32*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(&test._fld1)),
AdvSimd.LoadVector128((Int32*)(&test._fld2)),
AdvSimd.LoadVector128((Int32*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.AddRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper)}<Int16>(Vector64<Int16>, Vector128<Int32>, Vector128<Int32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddRoundedHighNarrowUpper)}<Int16>(Vector64<Int16>, Vector128<Int32>, Vector128<Int32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void SubtractReturningRoundedHighNarrowUpper_Vector128_Int32()
+ private static void AddRoundedHighNarrowUpper_Vector128_Int32()
{
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int32();
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int32
+ public sealed unsafe class SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int32 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int32 testClass)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int32 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int32 testClass)
{
fixed (Vector64<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
fixed (Vector128<Int64>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
AdvSimd.LoadVector128((Int64*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int32()
+ static SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int32>, byte>(ref _clsVar1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Int32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar3), ref Unsafe.As<Int64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
}
- public SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int32()
+ public SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<Int64>* pClsVar2 = &_clsVar2)
fixed (Vector128<Int64>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pClsVar1)),
AdvSimd.LoadVector128((Int64*)(pClsVar2)),
AdvSimd.LoadVector128((Int64*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int32();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int32();
+ var result = AdvSimd.AddRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_Int32();
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_Int32();
fixed (Vector64<Int32>* pFld1 = &test._fld1)
fixed (Vector128<Int64>* pFld2 = &test._fld2)
fixed (Vector128<Int64>* pFld3 = &test._fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
AdvSimd.LoadVector128((Int64*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<Int64>* pFld2 = &_fld2)
fixed (Vector128<Int64>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
AdvSimd.LoadVector128((Int64*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(&test._fld1)),
AdvSimd.LoadVector128((Int64*)(&test._fld2)),
AdvSimd.LoadVector128((Int64*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.AddRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper)}<Int32>(Vector64<Int32>, Vector128<Int64>, Vector128<Int64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddRoundedHighNarrowUpper)}<Int32>(Vector64<Int32>, Vector128<Int64>, Vector128<Int64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void SubtractReturningRoundedHighNarrowUpper_Vector128_SByte()
+ private static void AddRoundedHighNarrowUpper_Vector128_SByte()
{
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_SByte();
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_SByte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_SByte
+ public sealed unsafe class SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_SByte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_SByte testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_SByte testClass)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_SByte testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_SByte testClass)
{
fixed (Vector64<SByte>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
fixed (Vector128<Int16>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
AdvSimd.LoadVector128((Int16*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_SByte()
+ static SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_SByte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<SByte>, byte>(ref _clsVar1), ref Unsafe.As<SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<SByte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar3), ref Unsafe.As<Int16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
}
- public SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_SByte()
+ public SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_SByte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<Int16>* pClsVar2 = &_clsVar2)
fixed (Vector128<Int16>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pClsVar1)),
AdvSimd.LoadVector128((Int16*)(pClsVar2)),
AdvSimd.LoadVector128((Int16*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_SByte();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_SByte();
+ var result = AdvSimd.AddRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_SByte();
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_SByte();
fixed (Vector64<SByte>* pFld1 = &test._fld1)
fixed (Vector128<Int16>* pFld2 = &test._fld2)
fixed (Vector128<Int16>* pFld3 = &test._fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
AdvSimd.LoadVector128((Int16*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<Int16>* pFld2 = &_fld2)
fixed (Vector128<Int16>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
AdvSimd.LoadVector128((Int16*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(&test._fld1)),
AdvSimd.LoadVector128((Int16*)(&test._fld2)),
AdvSimd.LoadVector128((Int16*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.AddRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper)}<SByte>(Vector64<SByte>, Vector128<Int16>, Vector128<Int16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddRoundedHighNarrowUpper)}<SByte>(Vector64<SByte>, Vector128<Int16>, Vector128<Int16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void SubtractReturningRoundedHighNarrowUpper_Vector128_UInt16()
+ private static void AddRoundedHighNarrowUpper_Vector128_UInt16()
{
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt16();
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt16
+ public sealed unsafe class SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt16 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt16 testClass)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt16 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt16 testClass)
{
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
fixed (Vector128<UInt32>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
AdvSimd.LoadVector128((UInt32*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt16()
+ static SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar3), ref Unsafe.As<UInt32, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
}
- public SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt16()
+ public SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<UInt32>* pClsVar2 = &_clsVar2)
fixed (Vector128<UInt32>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pClsVar1)),
AdvSimd.LoadVector128((UInt32*)(pClsVar2)),
AdvSimd.LoadVector128((UInt32*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt16();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt16();
+ var result = AdvSimd.AddRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt16();
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt16();
fixed (Vector64<UInt16>* pFld1 = &test._fld1)
fixed (Vector128<UInt32>* pFld2 = &test._fld2)
fixed (Vector128<UInt32>* pFld3 = &test._fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
AdvSimd.LoadVector128((UInt32*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<UInt32>* pFld2 = &_fld2)
fixed (Vector128<UInt32>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
AdvSimd.LoadVector128((UInt32*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(&test._fld1)),
AdvSimd.LoadVector128((UInt32*)(&test._fld2)),
AdvSimd.LoadVector128((UInt32*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.AddRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper)}<UInt16>(Vector64<UInt16>, Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddRoundedHighNarrowUpper)}<UInt16>(Vector64<UInt16>, Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void SubtractReturningRoundedHighNarrowUpper_Vector128_UInt32()
+ private static void AddRoundedHighNarrowUpper_Vector128_UInt32()
{
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt32();
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt32
+ public sealed unsafe class SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt32 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt32 testClass)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt32 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt32 testClass)
{
fixed (Vector64<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
fixed (Vector128<UInt64>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
AdvSimd.LoadVector128((UInt64*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt32()
+ static SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt32>, byte>(ref _clsVar1), ref Unsafe.As<UInt32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar3), ref Unsafe.As<UInt64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
}
- public SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt32()
+ public SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<UInt64>* pClsVar2 = &_clsVar2)
fixed (Vector128<UInt64>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pClsVar1)),
AdvSimd.LoadVector128((UInt64*)(pClsVar2)),
AdvSimd.LoadVector128((UInt64*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt32();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt32();
+ var result = AdvSimd.AddRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__SubtractReturningRoundedHighNarrowUpper_Vector128_UInt32();
+ var test = new SimpleTernaryOpTest__AddRoundedHighNarrowUpper_Vector128_UInt32();
fixed (Vector64<UInt32>* pFld1 = &test._fld1)
fixed (Vector128<UInt64>* pFld2 = &test._fld2)
fixed (Vector128<UInt64>* pFld3 = &test._fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
AdvSimd.LoadVector128((UInt64*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<UInt64>* pFld2 = &_fld2)
fixed (Vector128<UInt64>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
AdvSimd.LoadVector128((UInt64*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.AddRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.AddRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(&test._fld1)),
AdvSimd.LoadVector128((UInt64*)(&test._fld2)),
AdvSimd.LoadVector128((UInt64*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.AddRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningRoundedHighNarrowUpper)}<UInt32>(Vector64<UInt32>, Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddRoundedHighNarrowUpper)}<UInt32>(Vector64<UInt32>, Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
<Compile Include="Add.Vector128.UInt16.cs" />
<Compile Include="Add.Vector128.UInt32.cs" />
<Compile Include="Add.Vector128.UInt64.cs" />
+ <Compile Include="AddHighNarrowLower.Vector64.Byte.cs" />
+ <Compile Include="AddHighNarrowLower.Vector64.Int16.cs" />
+ <Compile Include="AddHighNarrowLower.Vector64.Int32.cs" />
+ <Compile Include="AddHighNarrowLower.Vector64.SByte.cs" />
+ <Compile Include="AddHighNarrowLower.Vector64.UInt16.cs" />
+ <Compile Include="AddHighNarrowLower.Vector64.UInt32.cs" />
+ <Compile Include="AddHighNarrowUpper.Vector128.Byte.cs" />
+ <Compile Include="AddHighNarrowUpper.Vector128.Int16.cs" />
+ <Compile Include="AddHighNarrowUpper.Vector128.Int32.cs" />
+ <Compile Include="AddHighNarrowUpper.Vector128.SByte.cs" />
+ <Compile Include="AddHighNarrowUpper.Vector128.UInt16.cs" />
+ <Compile Include="AddHighNarrowUpper.Vector128.UInt32.cs" />
<Compile Include="AddPairwise.Vector64.Byte.cs" />
<Compile Include="AddPairwise.Vector64.Int16.cs" />
<Compile Include="AddPairwise.Vector64.Int32.cs" />
<Compile Include="AddPairwiseWideningAndAddScalar.Vector64.UInt32.cs" />
<Compile Include="AddPairwiseWideningScalar.Vector64.Int32.cs" />
<Compile Include="AddPairwiseWideningScalar.Vector64.UInt32.cs" />
- <Compile Include="AddReturningHighNarrowLower.Vector64.Byte.cs" />
- <Compile Include="AddReturningHighNarrowLower.Vector64.Int16.cs" />
- <Compile Include="AddReturningHighNarrowLower.Vector64.Int32.cs" />
- <Compile Include="AddReturningHighNarrowLower.Vector64.SByte.cs" />
- <Compile Include="AddReturningHighNarrowLower.Vector64.UInt16.cs" />
- <Compile Include="AddReturningHighNarrowLower.Vector64.UInt32.cs" />
- <Compile Include="AddReturningHighNarrowUpper.Vector128.Byte.cs" />
- <Compile Include="AddReturningHighNarrowUpper.Vector128.Int16.cs" />
- <Compile Include="AddReturningHighNarrowUpper.Vector128.Int32.cs" />
- <Compile Include="AddReturningHighNarrowUpper.Vector128.SByte.cs" />
- <Compile Include="AddReturningHighNarrowUpper.Vector128.UInt16.cs" />
- <Compile Include="AddReturningHighNarrowUpper.Vector128.UInt32.cs" />
- <Compile Include="AddReturningRoundedHighNarrowLower.Vector64.Byte.cs" />
- <Compile Include="AddReturningRoundedHighNarrowLower.Vector64.Int16.cs" />
- <Compile Include="AddReturningRoundedHighNarrowLower.Vector64.Int32.cs" />
- <Compile Include="AddReturningRoundedHighNarrowLower.Vector64.SByte.cs" />
- <Compile Include="AddReturningRoundedHighNarrowLower.Vector64.UInt16.cs" />
- <Compile Include="AddReturningRoundedHighNarrowLower.Vector64.UInt32.cs" />
- <Compile Include="AddReturningRoundedHighNarrowUpper.Vector128.Byte.cs" />
- <Compile Include="AddReturningRoundedHighNarrowUpper.Vector128.Int16.cs" />
- <Compile Include="AddReturningRoundedHighNarrowUpper.Vector128.Int32.cs" />
- <Compile Include="AddReturningRoundedHighNarrowUpper.Vector128.SByte.cs" />
- <Compile Include="AddReturningRoundedHighNarrowUpper.Vector128.UInt16.cs" />
- <Compile Include="AddReturningRoundedHighNarrowUpper.Vector128.UInt32.cs" />
+ <Compile Include="AddRoundedHighNarrowLower.Vector64.Byte.cs" />
+ <Compile Include="AddRoundedHighNarrowLower.Vector64.Int16.cs" />
+ <Compile Include="AddRoundedHighNarrowLower.Vector64.Int32.cs" />
+ <Compile Include="AddRoundedHighNarrowLower.Vector64.SByte.cs" />
+ <Compile Include="AddRoundedHighNarrowLower.Vector64.UInt16.cs" />
+ <Compile Include="AddRoundedHighNarrowLower.Vector64.UInt32.cs" />
+ <Compile Include="AddRoundedHighNarrowUpper.Vector128.Byte.cs" />
+ <Compile Include="AddRoundedHighNarrowUpper.Vector128.Int16.cs" />
+ <Compile Include="AddRoundedHighNarrowUpper.Vector128.Int32.cs" />
+ <Compile Include="AddRoundedHighNarrowUpper.Vector128.SByte.cs" />
+ <Compile Include="AddRoundedHighNarrowUpper.Vector128.UInt16.cs" />
+ <Compile Include="AddRoundedHighNarrowUpper.Vector128.UInt32.cs" />
<Compile Include="AddSaturate.Vector64.Byte.cs" />
<Compile Include="AddSaturate.Vector64.Int16.cs" />
<Compile Include="AddSaturate.Vector64.Int32.cs" />
<Compile Include="Subtract.Vector128.UInt16.cs" />
<Compile Include="Subtract.Vector128.UInt32.cs" />
<Compile Include="Subtract.Vector128.UInt64.cs" />
- <Compile Include="SubtractReturningHighNarrowLower.Vector64.Byte.cs" />
- <Compile Include="SubtractReturningHighNarrowLower.Vector64.Int16.cs" />
- <Compile Include="SubtractReturningHighNarrowLower.Vector64.Int32.cs" />
- <Compile Include="SubtractReturningHighNarrowLower.Vector64.SByte.cs" />
- <Compile Include="SubtractReturningHighNarrowLower.Vector64.UInt16.cs" />
- <Compile Include="SubtractReturningHighNarrowLower.Vector64.UInt32.cs" />
- <Compile Include="SubtractReturningHighNarrowUpper.Vector128.Byte.cs" />
- <Compile Include="SubtractReturningHighNarrowUpper.Vector128.Int16.cs" />
- <Compile Include="SubtractReturningHighNarrowUpper.Vector128.Int32.cs" />
- <Compile Include="SubtractReturningHighNarrowUpper.Vector128.SByte.cs" />
- <Compile Include="SubtractReturningHighNarrowUpper.Vector128.UInt16.cs" />
- <Compile Include="SubtractReturningHighNarrowUpper.Vector128.UInt32.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowLower.Vector64.Byte.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowLower.Vector64.Int16.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowLower.Vector64.Int32.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowLower.Vector64.SByte.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowLower.Vector64.UInt16.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowLower.Vector64.UInt32.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowUpper.Vector128.Byte.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowUpper.Vector128.Int16.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowUpper.Vector128.Int32.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowUpper.Vector128.SByte.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowUpper.Vector128.UInt16.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowUpper.Vector128.UInt32.cs" />
+ <Compile Include="SubtractHighNarrowLower.Vector64.Byte.cs" />
+ <Compile Include="SubtractHighNarrowLower.Vector64.Int16.cs" />
+ <Compile Include="SubtractHighNarrowLower.Vector64.Int32.cs" />
+ <Compile Include="SubtractHighNarrowLower.Vector64.SByte.cs" />
+ <Compile Include="SubtractHighNarrowLower.Vector64.UInt16.cs" />
+ <Compile Include="SubtractHighNarrowLower.Vector64.UInt32.cs" />
+ <Compile Include="SubtractHighNarrowUpper.Vector128.Byte.cs" />
+ <Compile Include="SubtractHighNarrowUpper.Vector128.Int16.cs" />
+ <Compile Include="SubtractHighNarrowUpper.Vector128.Int32.cs" />
+ <Compile Include="SubtractHighNarrowUpper.Vector128.SByte.cs" />
+ <Compile Include="SubtractHighNarrowUpper.Vector128.UInt16.cs" />
+ <Compile Include="SubtractHighNarrowUpper.Vector128.UInt32.cs" />
+ <Compile Include="SubtractRoundedHighNarrowLower.Vector64.Byte.cs" />
+ <Compile Include="SubtractRoundedHighNarrowLower.Vector64.Int16.cs" />
+ <Compile Include="SubtractRoundedHighNarrowLower.Vector64.Int32.cs" />
+ <Compile Include="SubtractRoundedHighNarrowLower.Vector64.SByte.cs" />
+ <Compile Include="SubtractRoundedHighNarrowLower.Vector64.UInt16.cs" />
+ <Compile Include="SubtractRoundedHighNarrowLower.Vector64.UInt32.cs" />
+ <Compile Include="SubtractRoundedHighNarrowUpper.Vector128.Byte.cs" />
+ <Compile Include="SubtractRoundedHighNarrowUpper.Vector128.Int16.cs" />
+ <Compile Include="SubtractRoundedHighNarrowUpper.Vector128.Int32.cs" />
+ <Compile Include="SubtractRoundedHighNarrowUpper.Vector128.SByte.cs" />
+ <Compile Include="SubtractRoundedHighNarrowUpper.Vector128.UInt16.cs" />
+ <Compile Include="SubtractRoundedHighNarrowUpper.Vector128.UInt32.cs" />
<Compile Include="SubtractSaturate.Vector64.Byte.cs" />
<Compile Include="SubtractSaturate.Vector64.Int16.cs" />
<Compile Include="SubtractSaturate.Vector64.Int32.cs" />
<Compile Include="Add.Vector128.UInt16.cs" />
<Compile Include="Add.Vector128.UInt32.cs" />
<Compile Include="Add.Vector128.UInt64.cs" />
+ <Compile Include="AddHighNarrowLower.Vector64.Byte.cs" />
+ <Compile Include="AddHighNarrowLower.Vector64.Int16.cs" />
+ <Compile Include="AddHighNarrowLower.Vector64.Int32.cs" />
+ <Compile Include="AddHighNarrowLower.Vector64.SByte.cs" />
+ <Compile Include="AddHighNarrowLower.Vector64.UInt16.cs" />
+ <Compile Include="AddHighNarrowLower.Vector64.UInt32.cs" />
+ <Compile Include="AddHighNarrowUpper.Vector128.Byte.cs" />
+ <Compile Include="AddHighNarrowUpper.Vector128.Int16.cs" />
+ <Compile Include="AddHighNarrowUpper.Vector128.Int32.cs" />
+ <Compile Include="AddHighNarrowUpper.Vector128.SByte.cs" />
+ <Compile Include="AddHighNarrowUpper.Vector128.UInt16.cs" />
+ <Compile Include="AddHighNarrowUpper.Vector128.UInt32.cs" />
<Compile Include="AddPairwise.Vector64.Byte.cs" />
<Compile Include="AddPairwise.Vector64.Int16.cs" />
<Compile Include="AddPairwise.Vector64.Int32.cs" />
<Compile Include="AddPairwiseWideningAndAddScalar.Vector64.UInt32.cs" />
<Compile Include="AddPairwiseWideningScalar.Vector64.Int32.cs" />
<Compile Include="AddPairwiseWideningScalar.Vector64.UInt32.cs" />
- <Compile Include="AddReturningHighNarrowLower.Vector64.Byte.cs" />
- <Compile Include="AddReturningHighNarrowLower.Vector64.Int16.cs" />
- <Compile Include="AddReturningHighNarrowLower.Vector64.Int32.cs" />
- <Compile Include="AddReturningHighNarrowLower.Vector64.SByte.cs" />
- <Compile Include="AddReturningHighNarrowLower.Vector64.UInt16.cs" />
- <Compile Include="AddReturningHighNarrowLower.Vector64.UInt32.cs" />
- <Compile Include="AddReturningHighNarrowUpper.Vector128.Byte.cs" />
- <Compile Include="AddReturningHighNarrowUpper.Vector128.Int16.cs" />
- <Compile Include="AddReturningHighNarrowUpper.Vector128.Int32.cs" />
- <Compile Include="AddReturningHighNarrowUpper.Vector128.SByte.cs" />
- <Compile Include="AddReturningHighNarrowUpper.Vector128.UInt16.cs" />
- <Compile Include="AddReturningHighNarrowUpper.Vector128.UInt32.cs" />
- <Compile Include="AddReturningRoundedHighNarrowLower.Vector64.Byte.cs" />
- <Compile Include="AddReturningRoundedHighNarrowLower.Vector64.Int16.cs" />
- <Compile Include="AddReturningRoundedHighNarrowLower.Vector64.Int32.cs" />
- <Compile Include="AddReturningRoundedHighNarrowLower.Vector64.SByte.cs" />
- <Compile Include="AddReturningRoundedHighNarrowLower.Vector64.UInt16.cs" />
- <Compile Include="AddReturningRoundedHighNarrowLower.Vector64.UInt32.cs" />
- <Compile Include="AddReturningRoundedHighNarrowUpper.Vector128.Byte.cs" />
- <Compile Include="AddReturningRoundedHighNarrowUpper.Vector128.Int16.cs" />
- <Compile Include="AddReturningRoundedHighNarrowUpper.Vector128.Int32.cs" />
- <Compile Include="AddReturningRoundedHighNarrowUpper.Vector128.SByte.cs" />
- <Compile Include="AddReturningRoundedHighNarrowUpper.Vector128.UInt16.cs" />
- <Compile Include="AddReturningRoundedHighNarrowUpper.Vector128.UInt32.cs" />
+ <Compile Include="AddRoundedHighNarrowLower.Vector64.Byte.cs" />
+ <Compile Include="AddRoundedHighNarrowLower.Vector64.Int16.cs" />
+ <Compile Include="AddRoundedHighNarrowLower.Vector64.Int32.cs" />
+ <Compile Include="AddRoundedHighNarrowLower.Vector64.SByte.cs" />
+ <Compile Include="AddRoundedHighNarrowLower.Vector64.UInt16.cs" />
+ <Compile Include="AddRoundedHighNarrowLower.Vector64.UInt32.cs" />
+ <Compile Include="AddRoundedHighNarrowUpper.Vector128.Byte.cs" />
+ <Compile Include="AddRoundedHighNarrowUpper.Vector128.Int16.cs" />
+ <Compile Include="AddRoundedHighNarrowUpper.Vector128.Int32.cs" />
+ <Compile Include="AddRoundedHighNarrowUpper.Vector128.SByte.cs" />
+ <Compile Include="AddRoundedHighNarrowUpper.Vector128.UInt16.cs" />
+ <Compile Include="AddRoundedHighNarrowUpper.Vector128.UInt32.cs" />
<Compile Include="AddSaturate.Vector64.Byte.cs" />
<Compile Include="AddSaturate.Vector64.Int16.cs" />
<Compile Include="AddSaturate.Vector64.Int32.cs" />
<Compile Include="Subtract.Vector128.UInt16.cs" />
<Compile Include="Subtract.Vector128.UInt32.cs" />
<Compile Include="Subtract.Vector128.UInt64.cs" />
- <Compile Include="SubtractReturningHighNarrowLower.Vector64.Byte.cs" />
- <Compile Include="SubtractReturningHighNarrowLower.Vector64.Int16.cs" />
- <Compile Include="SubtractReturningHighNarrowLower.Vector64.Int32.cs" />
- <Compile Include="SubtractReturningHighNarrowLower.Vector64.SByte.cs" />
- <Compile Include="SubtractReturningHighNarrowLower.Vector64.UInt16.cs" />
- <Compile Include="SubtractReturningHighNarrowLower.Vector64.UInt32.cs" />
- <Compile Include="SubtractReturningHighNarrowUpper.Vector128.Byte.cs" />
- <Compile Include="SubtractReturningHighNarrowUpper.Vector128.Int16.cs" />
- <Compile Include="SubtractReturningHighNarrowUpper.Vector128.Int32.cs" />
- <Compile Include="SubtractReturningHighNarrowUpper.Vector128.SByte.cs" />
- <Compile Include="SubtractReturningHighNarrowUpper.Vector128.UInt16.cs" />
- <Compile Include="SubtractReturningHighNarrowUpper.Vector128.UInt32.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowLower.Vector64.Byte.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowLower.Vector64.Int16.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowLower.Vector64.Int32.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowLower.Vector64.SByte.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowLower.Vector64.UInt16.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowLower.Vector64.UInt32.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowUpper.Vector128.Byte.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowUpper.Vector128.Int16.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowUpper.Vector128.Int32.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowUpper.Vector128.SByte.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowUpper.Vector128.UInt16.cs" />
- <Compile Include="SubtractReturningRoundedHighNarrowUpper.Vector128.UInt32.cs" />
+ <Compile Include="SubtractHighNarrowLower.Vector64.Byte.cs" />
+ <Compile Include="SubtractHighNarrowLower.Vector64.Int16.cs" />
+ <Compile Include="SubtractHighNarrowLower.Vector64.Int32.cs" />
+ <Compile Include="SubtractHighNarrowLower.Vector64.SByte.cs" />
+ <Compile Include="SubtractHighNarrowLower.Vector64.UInt16.cs" />
+ <Compile Include="SubtractHighNarrowLower.Vector64.UInt32.cs" />
+ <Compile Include="SubtractHighNarrowUpper.Vector128.Byte.cs" />
+ <Compile Include="SubtractHighNarrowUpper.Vector128.Int16.cs" />
+ <Compile Include="SubtractHighNarrowUpper.Vector128.Int32.cs" />
+ <Compile Include="SubtractHighNarrowUpper.Vector128.SByte.cs" />
+ <Compile Include="SubtractHighNarrowUpper.Vector128.UInt16.cs" />
+ <Compile Include="SubtractHighNarrowUpper.Vector128.UInt32.cs" />
+ <Compile Include="SubtractRoundedHighNarrowLower.Vector64.Byte.cs" />
+ <Compile Include="SubtractRoundedHighNarrowLower.Vector64.Int16.cs" />
+ <Compile Include="SubtractRoundedHighNarrowLower.Vector64.Int32.cs" />
+ <Compile Include="SubtractRoundedHighNarrowLower.Vector64.SByte.cs" />
+ <Compile Include="SubtractRoundedHighNarrowLower.Vector64.UInt16.cs" />
+ <Compile Include="SubtractRoundedHighNarrowLower.Vector64.UInt32.cs" />
+ <Compile Include="SubtractRoundedHighNarrowUpper.Vector128.Byte.cs" />
+ <Compile Include="SubtractRoundedHighNarrowUpper.Vector128.Int16.cs" />
+ <Compile Include="SubtractRoundedHighNarrowUpper.Vector128.Int32.cs" />
+ <Compile Include="SubtractRoundedHighNarrowUpper.Vector128.SByte.cs" />
+ <Compile Include="SubtractRoundedHighNarrowUpper.Vector128.UInt16.cs" />
+ <Compile Include="SubtractRoundedHighNarrowUpper.Vector128.UInt32.cs" />
<Compile Include="SubtractSaturate.Vector64.Byte.cs" />
<Compile Include="SubtractSaturate.Vector64.Int16.cs" />
<Compile Include="SubtractSaturate.Vector64.Int32.cs" />
["Add.Vector128.UInt16"] = Add_Vector128_UInt16,
["Add.Vector128.UInt32"] = Add_Vector128_UInt32,
["Add.Vector128.UInt64"] = Add_Vector128_UInt64,
+ ["AddHighNarrowLower.Vector64.Byte"] = AddHighNarrowLower_Vector64_Byte,
+ ["AddHighNarrowLower.Vector64.Int16"] = AddHighNarrowLower_Vector64_Int16,
+ ["AddHighNarrowLower.Vector64.Int32"] = AddHighNarrowLower_Vector64_Int32,
+ ["AddHighNarrowLower.Vector64.SByte"] = AddHighNarrowLower_Vector64_SByte,
+ ["AddHighNarrowLower.Vector64.UInt16"] = AddHighNarrowLower_Vector64_UInt16,
+ ["AddHighNarrowLower.Vector64.UInt32"] = AddHighNarrowLower_Vector64_UInt32,
+ ["AddHighNarrowUpper.Vector128.Byte"] = AddHighNarrowUpper_Vector128_Byte,
+ ["AddHighNarrowUpper.Vector128.Int16"] = AddHighNarrowUpper_Vector128_Int16,
+ ["AddHighNarrowUpper.Vector128.Int32"] = AddHighNarrowUpper_Vector128_Int32,
+ ["AddHighNarrowUpper.Vector128.SByte"] = AddHighNarrowUpper_Vector128_SByte,
+ ["AddHighNarrowUpper.Vector128.UInt16"] = AddHighNarrowUpper_Vector128_UInt16,
+ ["AddHighNarrowUpper.Vector128.UInt32"] = AddHighNarrowUpper_Vector128_UInt32,
["AddPairwise.Vector64.Byte"] = AddPairwise_Vector64_Byte,
["AddPairwise.Vector64.Int16"] = AddPairwise_Vector64_Int16,
["AddPairwise.Vector64.Int32"] = AddPairwise_Vector64_Int32,
["AddPairwiseWideningAndAddScalar.Vector64.UInt32"] = AddPairwiseWideningAndAddScalar_Vector64_UInt32,
["AddPairwiseWideningScalar.Vector64.Int32"] = AddPairwiseWideningScalar_Vector64_Int32,
["AddPairwiseWideningScalar.Vector64.UInt32"] = AddPairwiseWideningScalar_Vector64_UInt32,
- ["AddReturningHighNarrowLower.Vector64.Byte"] = AddReturningHighNarrowLower_Vector64_Byte,
- ["AddReturningHighNarrowLower.Vector64.Int16"] = AddReturningHighNarrowLower_Vector64_Int16,
- ["AddReturningHighNarrowLower.Vector64.Int32"] = AddReturningHighNarrowLower_Vector64_Int32,
- ["AddReturningHighNarrowLower.Vector64.SByte"] = AddReturningHighNarrowLower_Vector64_SByte,
- ["AddReturningHighNarrowLower.Vector64.UInt16"] = AddReturningHighNarrowLower_Vector64_UInt16,
- ["AddReturningHighNarrowLower.Vector64.UInt32"] = AddReturningHighNarrowLower_Vector64_UInt32,
- ["AddReturningHighNarrowUpper.Vector128.Byte"] = AddReturningHighNarrowUpper_Vector128_Byte,
- ["AddReturningHighNarrowUpper.Vector128.Int16"] = AddReturningHighNarrowUpper_Vector128_Int16,
- ["AddReturningHighNarrowUpper.Vector128.Int32"] = AddReturningHighNarrowUpper_Vector128_Int32,
- ["AddReturningHighNarrowUpper.Vector128.SByte"] = AddReturningHighNarrowUpper_Vector128_SByte,
- ["AddReturningHighNarrowUpper.Vector128.UInt16"] = AddReturningHighNarrowUpper_Vector128_UInt16,
- ["AddReturningHighNarrowUpper.Vector128.UInt32"] = AddReturningHighNarrowUpper_Vector128_UInt32,
- ["AddReturningRoundedHighNarrowLower.Vector64.Byte"] = AddReturningRoundedHighNarrowLower_Vector64_Byte,
- ["AddReturningRoundedHighNarrowLower.Vector64.Int16"] = AddReturningRoundedHighNarrowLower_Vector64_Int16,
- ["AddReturningRoundedHighNarrowLower.Vector64.Int32"] = AddReturningRoundedHighNarrowLower_Vector64_Int32,
- ["AddReturningRoundedHighNarrowLower.Vector64.SByte"] = AddReturningRoundedHighNarrowLower_Vector64_SByte,
- ["AddReturningRoundedHighNarrowLower.Vector64.UInt16"] = AddReturningRoundedHighNarrowLower_Vector64_UInt16,
- ["AddReturningRoundedHighNarrowLower.Vector64.UInt32"] = AddReturningRoundedHighNarrowLower_Vector64_UInt32,
- ["AddReturningRoundedHighNarrowUpper.Vector128.Byte"] = AddReturningRoundedHighNarrowUpper_Vector128_Byte,
- ["AddReturningRoundedHighNarrowUpper.Vector128.Int16"] = AddReturningRoundedHighNarrowUpper_Vector128_Int16,
- ["AddReturningRoundedHighNarrowUpper.Vector128.Int32"] = AddReturningRoundedHighNarrowUpper_Vector128_Int32,
- ["AddReturningRoundedHighNarrowUpper.Vector128.SByte"] = AddReturningRoundedHighNarrowUpper_Vector128_SByte,
- ["AddReturningRoundedHighNarrowUpper.Vector128.UInt16"] = AddReturningRoundedHighNarrowUpper_Vector128_UInt16,
- ["AddReturningRoundedHighNarrowUpper.Vector128.UInt32"] = AddReturningRoundedHighNarrowUpper_Vector128_UInt32,
+ ["AddRoundedHighNarrowLower.Vector64.Byte"] = AddRoundedHighNarrowLower_Vector64_Byte,
+ ["AddRoundedHighNarrowLower.Vector64.Int16"] = AddRoundedHighNarrowLower_Vector64_Int16,
+ ["AddRoundedHighNarrowLower.Vector64.Int32"] = AddRoundedHighNarrowLower_Vector64_Int32,
+ ["AddRoundedHighNarrowLower.Vector64.SByte"] = AddRoundedHighNarrowLower_Vector64_SByte,
+ ["AddRoundedHighNarrowLower.Vector64.UInt16"] = AddRoundedHighNarrowLower_Vector64_UInt16,
+ ["AddRoundedHighNarrowLower.Vector64.UInt32"] = AddRoundedHighNarrowLower_Vector64_UInt32,
+ ["AddRoundedHighNarrowUpper.Vector128.Byte"] = AddRoundedHighNarrowUpper_Vector128_Byte,
+ ["AddRoundedHighNarrowUpper.Vector128.Int16"] = AddRoundedHighNarrowUpper_Vector128_Int16,
+ ["AddRoundedHighNarrowUpper.Vector128.Int32"] = AddRoundedHighNarrowUpper_Vector128_Int32,
+ ["AddRoundedHighNarrowUpper.Vector128.SByte"] = AddRoundedHighNarrowUpper_Vector128_SByte,
+ ["AddRoundedHighNarrowUpper.Vector128.UInt16"] = AddRoundedHighNarrowUpper_Vector128_UInt16,
+ ["AddRoundedHighNarrowUpper.Vector128.UInt32"] = AddRoundedHighNarrowUpper_Vector128_UInt32,
["AddSaturate.Vector64.Byte"] = AddSaturate_Vector64_Byte,
["AddSaturate.Vector64.Int16"] = AddSaturate_Vector64_Int16,
["AddSaturate.Vector64.Int32"] = AddSaturate_Vector64_Int32,
["Subtract.Vector128.UInt16"] = Subtract_Vector128_UInt16,
["Subtract.Vector128.UInt32"] = Subtract_Vector128_UInt32,
["Subtract.Vector128.UInt64"] = Subtract_Vector128_UInt64,
- ["SubtractReturningHighNarrowLower.Vector64.Byte"] = SubtractReturningHighNarrowLower_Vector64_Byte,
- ["SubtractReturningHighNarrowLower.Vector64.Int16"] = SubtractReturningHighNarrowLower_Vector64_Int16,
- ["SubtractReturningHighNarrowLower.Vector64.Int32"] = SubtractReturningHighNarrowLower_Vector64_Int32,
- ["SubtractReturningHighNarrowLower.Vector64.SByte"] = SubtractReturningHighNarrowLower_Vector64_SByte,
- ["SubtractReturningHighNarrowLower.Vector64.UInt16"] = SubtractReturningHighNarrowLower_Vector64_UInt16,
- ["SubtractReturningHighNarrowLower.Vector64.UInt32"] = SubtractReturningHighNarrowLower_Vector64_UInt32,
- ["SubtractReturningHighNarrowUpper.Vector128.Byte"] = SubtractReturningHighNarrowUpper_Vector128_Byte,
- ["SubtractReturningHighNarrowUpper.Vector128.Int16"] = SubtractReturningHighNarrowUpper_Vector128_Int16,
- ["SubtractReturningHighNarrowUpper.Vector128.Int32"] = SubtractReturningHighNarrowUpper_Vector128_Int32,
- ["SubtractReturningHighNarrowUpper.Vector128.SByte"] = SubtractReturningHighNarrowUpper_Vector128_SByte,
- ["SubtractReturningHighNarrowUpper.Vector128.UInt16"] = SubtractReturningHighNarrowUpper_Vector128_UInt16,
- ["SubtractReturningHighNarrowUpper.Vector128.UInt32"] = SubtractReturningHighNarrowUpper_Vector128_UInt32,
- ["SubtractReturningRoundedHighNarrowLower.Vector64.Byte"] = SubtractReturningRoundedHighNarrowLower_Vector64_Byte,
- ["SubtractReturningRoundedHighNarrowLower.Vector64.Int16"] = SubtractReturningRoundedHighNarrowLower_Vector64_Int16,
- ["SubtractReturningRoundedHighNarrowLower.Vector64.Int32"] = SubtractReturningRoundedHighNarrowLower_Vector64_Int32,
- ["SubtractReturningRoundedHighNarrowLower.Vector64.SByte"] = SubtractReturningRoundedHighNarrowLower_Vector64_SByte,
- ["SubtractReturningRoundedHighNarrowLower.Vector64.UInt16"] = SubtractReturningRoundedHighNarrowLower_Vector64_UInt16,
- ["SubtractReturningRoundedHighNarrowLower.Vector64.UInt32"] = SubtractReturningRoundedHighNarrowLower_Vector64_UInt32,
- ["SubtractReturningRoundedHighNarrowUpper.Vector128.Byte"] = SubtractReturningRoundedHighNarrowUpper_Vector128_Byte,
- ["SubtractReturningRoundedHighNarrowUpper.Vector128.Int16"] = SubtractReturningRoundedHighNarrowUpper_Vector128_Int16,
- ["SubtractReturningRoundedHighNarrowUpper.Vector128.Int32"] = SubtractReturningRoundedHighNarrowUpper_Vector128_Int32,
- ["SubtractReturningRoundedHighNarrowUpper.Vector128.SByte"] = SubtractReturningRoundedHighNarrowUpper_Vector128_SByte,
- ["SubtractReturningRoundedHighNarrowUpper.Vector128.UInt16"] = SubtractReturningRoundedHighNarrowUpper_Vector128_UInt16,
- ["SubtractReturningRoundedHighNarrowUpper.Vector128.UInt32"] = SubtractReturningRoundedHighNarrowUpper_Vector128_UInt32,
+ ["SubtractHighNarrowLower.Vector64.Byte"] = SubtractHighNarrowLower_Vector64_Byte,
+ ["SubtractHighNarrowLower.Vector64.Int16"] = SubtractHighNarrowLower_Vector64_Int16,
+ ["SubtractHighNarrowLower.Vector64.Int32"] = SubtractHighNarrowLower_Vector64_Int32,
+ ["SubtractHighNarrowLower.Vector64.SByte"] = SubtractHighNarrowLower_Vector64_SByte,
+ ["SubtractHighNarrowLower.Vector64.UInt16"] = SubtractHighNarrowLower_Vector64_UInt16,
+ ["SubtractHighNarrowLower.Vector64.UInt32"] = SubtractHighNarrowLower_Vector64_UInt32,
+ ["SubtractHighNarrowUpper.Vector128.Byte"] = SubtractHighNarrowUpper_Vector128_Byte,
+ ["SubtractHighNarrowUpper.Vector128.Int16"] = SubtractHighNarrowUpper_Vector128_Int16,
+ ["SubtractHighNarrowUpper.Vector128.Int32"] = SubtractHighNarrowUpper_Vector128_Int32,
+ ["SubtractHighNarrowUpper.Vector128.SByte"] = SubtractHighNarrowUpper_Vector128_SByte,
+ ["SubtractHighNarrowUpper.Vector128.UInt16"] = SubtractHighNarrowUpper_Vector128_UInt16,
+ ["SubtractHighNarrowUpper.Vector128.UInt32"] = SubtractHighNarrowUpper_Vector128_UInt32,
+ ["SubtractRoundedHighNarrowLower.Vector64.Byte"] = SubtractRoundedHighNarrowLower_Vector64_Byte,
+ ["SubtractRoundedHighNarrowLower.Vector64.Int16"] = SubtractRoundedHighNarrowLower_Vector64_Int16,
+ ["SubtractRoundedHighNarrowLower.Vector64.Int32"] = SubtractRoundedHighNarrowLower_Vector64_Int32,
+ ["SubtractRoundedHighNarrowLower.Vector64.SByte"] = SubtractRoundedHighNarrowLower_Vector64_SByte,
+ ["SubtractRoundedHighNarrowLower.Vector64.UInt16"] = SubtractRoundedHighNarrowLower_Vector64_UInt16,
+ ["SubtractRoundedHighNarrowLower.Vector64.UInt32"] = SubtractRoundedHighNarrowLower_Vector64_UInt32,
+ ["SubtractRoundedHighNarrowUpper.Vector128.Byte"] = SubtractRoundedHighNarrowUpper_Vector128_Byte,
+ ["SubtractRoundedHighNarrowUpper.Vector128.Int16"] = SubtractRoundedHighNarrowUpper_Vector128_Int16,
+ ["SubtractRoundedHighNarrowUpper.Vector128.Int32"] = SubtractRoundedHighNarrowUpper_Vector128_Int32,
+ ["SubtractRoundedHighNarrowUpper.Vector128.SByte"] = SubtractRoundedHighNarrowUpper_Vector128_SByte,
+ ["SubtractRoundedHighNarrowUpper.Vector128.UInt16"] = SubtractRoundedHighNarrowUpper_Vector128_UInt16,
+ ["SubtractRoundedHighNarrowUpper.Vector128.UInt32"] = SubtractRoundedHighNarrowUpper_Vector128_UInt32,
["SubtractSaturate.Vector64.Byte"] = SubtractSaturate_Vector64_Byte,
["SubtractSaturate.Vector64.Int16"] = SubtractSaturate_Vector64_Int16,
["SubtractSaturate.Vector64.Int32"] = SubtractSaturate_Vector64_Int32,
{
public static partial class Program
{
- private static void AddReturningHighNarrowLower_Vector64_Byte()
+ private static void SubtractHighNarrowLower_Vector64_Byte()
{
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Byte();
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Byte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Byte
+ public sealed unsafe class SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Byte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Byte testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Byte testClass)
{
- var result = AdvSimd.AddReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Byte testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Byte testClass)
{
fixed (Vector128<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Byte()
+ static SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Byte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar2), ref Unsafe.As<UInt16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
- public SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Byte()
+ public SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Byte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<UInt16>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt16>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pClsVar1)),
AdvSimd.LoadVector128((UInt16*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.AddReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.AddReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Byte();
- var result = AdvSimd.AddReturningHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Byte();
+ var result = AdvSimd.SubtractHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Byte();
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Byte();
fixed (Vector128<UInt16>* pFld1 = &test._fld1)
fixed (Vector128<UInt16>* pFld2 = &test._fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(&test._fld1)),
AdvSimd.LoadVector128((UInt16*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.SubtractHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningHighNarrowLower)}<Byte>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractHighNarrowLower)}<Byte>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void AddReturningHighNarrowLower_Vector64_Int16()
+ private static void SubtractHighNarrowLower_Vector64_Int16()
{
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int16();
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int16
+ public sealed unsafe class SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int16 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int16 testClass)
{
- var result = AdvSimd.AddReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int16 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int16 testClass)
{
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int16()
+ static SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar2), ref Unsafe.As<Int32, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
}
- public SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int16()
+ public SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<Int32>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int32>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pClsVar1)),
AdvSimd.LoadVector128((Int32*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.AddReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.AddReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int16();
- var result = AdvSimd.AddReturningHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int16();
+ var result = AdvSimd.SubtractHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int16();
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int16();
fixed (Vector128<Int32>* pFld1 = &test._fld1)
fixed (Vector128<Int32>* pFld2 = &test._fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(&test._fld1)),
AdvSimd.LoadVector128((Int32*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.SubtractHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningHighNarrowLower)}<Int16>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractHighNarrowLower)}<Int16>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void AddReturningHighNarrowLower_Vector64_Int32()
+ private static void SubtractHighNarrowLower_Vector64_Int32()
{
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int32();
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int32
+ public sealed unsafe class SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int32 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int32 testClass)
{
- var result = AdvSimd.AddReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int32 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int32 testClass)
{
fixed (Vector128<Int64>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int32()
+ static SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar1), ref Unsafe.As<Int64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar2), ref Unsafe.As<Int64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
}
- public SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int32()
+ public SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<Int64>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pClsVar1)),
AdvSimd.LoadVector128((Int64*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.AddReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.AddReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int32();
- var result = AdvSimd.AddReturningHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int32();
+ var result = AdvSimd.SubtractHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_Int32();
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_Int32();
fixed (Vector128<Int64>* pFld1 = &test._fld1)
fixed (Vector128<Int64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Int64>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(&test._fld1)),
AdvSimd.LoadVector128((Int64*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.SubtractHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningHighNarrowLower)}<Int32>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractHighNarrowLower)}<Int32>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void AddReturningHighNarrowLower_Vector64_SByte()
+ private static void SubtractHighNarrowLower_Vector64_SByte()
{
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_SByte();
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_SByte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_SByte
+ public sealed unsafe class SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_SByte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_SByte testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_SByte testClass)
{
- var result = AdvSimd.AddReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_SByte testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_SByte testClass)
{
fixed (Vector128<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_SByte()
+ static SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_SByte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar1), ref Unsafe.As<Int16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar2), ref Unsafe.As<Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
}
- public SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_SByte()
+ public SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_SByte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<Int16>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int16>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pClsVar1)),
AdvSimd.LoadVector128((Int16*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.AddReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.AddReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_SByte();
- var result = AdvSimd.AddReturningHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_SByte();
+ var result = AdvSimd.SubtractHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_SByte();
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_SByte();
fixed (Vector128<Int16>* pFld1 = &test._fld1)
fixed (Vector128<Int16>* pFld2 = &test._fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(&test._fld1)),
AdvSimd.LoadVector128((Int16*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.SubtractHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningHighNarrowLower)}<SByte>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractHighNarrowLower)}<SByte>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void AddReturningHighNarrowLower_Vector64_UInt16()
+ private static void SubtractHighNarrowLower_Vector64_UInt16()
{
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt16();
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt16
+ public sealed unsafe class SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt16 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt16 testClass)
{
- var result = AdvSimd.AddReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt16 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt16 testClass)
{
fixed (Vector128<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt16()
+ static SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar1), ref Unsafe.As<UInt32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar2), ref Unsafe.As<UInt32, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
}
- public SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt16()
+ public SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<UInt32>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt32>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pClsVar1)),
AdvSimd.LoadVector128((UInt32*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.AddReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.AddReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt16();
- var result = AdvSimd.AddReturningHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt16();
+ var result = AdvSimd.SubtractHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt16();
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt16();
fixed (Vector128<UInt32>* pFld1 = &test._fld1)
fixed (Vector128<UInt32>* pFld2 = &test._fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(&test._fld1)),
AdvSimd.LoadVector128((UInt32*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.SubtractHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningHighNarrowLower)}<UInt16>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractHighNarrowLower)}<UInt16>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void AddReturningHighNarrowLower_Vector64_UInt32()
+ private static void SubtractHighNarrowLower_Vector64_UInt32()
{
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt32();
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt32
+ public sealed unsafe class SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt32 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt32 testClass)
{
- var result = AdvSimd.AddReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt32 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt32 testClass)
{
fixed (Vector128<UInt64>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt32()
+ static SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar1), ref Unsafe.As<UInt64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar2), ref Unsafe.As<UInt64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
}
- public SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt32()
+ public SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<UInt64>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pClsVar1)),
AdvSimd.LoadVector128((UInt64*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.AddReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.AddReturningHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt32();
- var result = AdvSimd.AddReturningHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt32();
+ var result = AdvSimd.SubtractHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__AddReturningHighNarrowLower_Vector64_UInt32();
+ var test = new SimpleBinaryOpTest__SubtractHighNarrowLower_Vector64_UInt32();
fixed (Vector128<UInt64>* pFld1 = &test._fld1)
fixed (Vector128<UInt64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<UInt64>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.SubtractHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowLower(
+ var result = AdvSimd.SubtractHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(&test._fld1)),
AdvSimd.LoadVector128((UInt64*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.SubtractHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningHighNarrowLower)}<UInt32>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractHighNarrowLower)}<UInt32>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void AddReturningHighNarrowUpper_Vector128_Byte()
+ private static void SubtractHighNarrowUpper_Vector128_Byte()
{
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Byte();
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Byte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Byte
+ public sealed unsafe class SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Byte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Byte testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Byte testClass)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Byte testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Byte testClass)
{
fixed (Vector64<Byte>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
fixed (Vector128<UInt16>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
AdvSimd.LoadVector128((UInt16*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Byte()
+ static SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Byte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _clsVar1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar3), ref Unsafe.As<UInt16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
- public SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Byte()
+ public SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Byte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<UInt16>* pClsVar2 = &_clsVar2)
fixed (Vector128<UInt16>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pClsVar1)),
AdvSimd.LoadVector128((UInt16*)(pClsVar2)),
AdvSimd.LoadVector128((UInt16*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.AddReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.AddReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Byte();
- var result = AdvSimd.AddReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Byte();
+ var result = AdvSimd.SubtractHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Byte();
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Byte();
fixed (Vector64<Byte>* pFld1 = &test._fld1)
fixed (Vector128<UInt16>* pFld2 = &test._fld2)
fixed (Vector128<UInt16>* pFld3 = &test._fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
AdvSimd.LoadVector128((UInt16*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<UInt16>* pFld2 = &_fld2)
fixed (Vector128<UInt16>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
AdvSimd.LoadVector128((UInt16*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(&test._fld1)),
AdvSimd.LoadVector128((UInt16*)(&test._fld2)),
AdvSimd.LoadVector128((UInt16*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.SubtractHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningHighNarrowUpper)}<Byte>(Vector64<Byte>, Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractHighNarrowUpper)}<Byte>(Vector64<Byte>, Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void AddReturningHighNarrowUpper_Vector128_Int16()
+ private static void SubtractHighNarrowUpper_Vector128_Int16()
{
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int16();
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int16
+ public sealed unsafe class SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int16 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int16 testClass)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int16 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int16 testClass)
{
fixed (Vector64<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
fixed (Vector128<Int32>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
AdvSimd.LoadVector128((Int32*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int16()
+ static SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _clsVar1), ref Unsafe.As<Int16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar3), ref Unsafe.As<Int32, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
}
- public SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int16()
+ public SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<Int32>* pClsVar2 = &_clsVar2)
fixed (Vector128<Int32>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pClsVar1)),
AdvSimd.LoadVector128((Int32*)(pClsVar2)),
AdvSimd.LoadVector128((Int32*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.AddReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.AddReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int16();
- var result = AdvSimd.AddReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int16();
+ var result = AdvSimd.SubtractHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int16();
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int16();
fixed (Vector64<Int16>* pFld1 = &test._fld1)
fixed (Vector128<Int32>* pFld2 = &test._fld2)
fixed (Vector128<Int32>* pFld3 = &test._fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
AdvSimd.LoadVector128((Int32*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<Int32>* pFld2 = &_fld2)
fixed (Vector128<Int32>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
AdvSimd.LoadVector128((Int32*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(&test._fld1)),
AdvSimd.LoadVector128((Int32*)(&test._fld2)),
AdvSimd.LoadVector128((Int32*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.SubtractHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningHighNarrowUpper)}<Int16>(Vector64<Int16>, Vector128<Int32>, Vector128<Int32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractHighNarrowUpper)}<Int16>(Vector64<Int16>, Vector128<Int32>, Vector128<Int32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void AddReturningHighNarrowUpper_Vector128_Int32()
+ private static void SubtractHighNarrowUpper_Vector128_Int32()
{
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int32();
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int32
+ public sealed unsafe class SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int32 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int32 testClass)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int32 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int32 testClass)
{
fixed (Vector64<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
fixed (Vector128<Int64>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
AdvSimd.LoadVector128((Int64*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int32()
+ static SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int32>, byte>(ref _clsVar1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Int32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar3), ref Unsafe.As<Int64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
}
- public SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int32()
+ public SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<Int64>* pClsVar2 = &_clsVar2)
fixed (Vector128<Int64>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pClsVar1)),
AdvSimd.LoadVector128((Int64*)(pClsVar2)),
AdvSimd.LoadVector128((Int64*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.AddReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.AddReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int32();
- var result = AdvSimd.AddReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int32();
+ var result = AdvSimd.SubtractHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_Int32();
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_Int32();
fixed (Vector64<Int32>* pFld1 = &test._fld1)
fixed (Vector128<Int64>* pFld2 = &test._fld2)
fixed (Vector128<Int64>* pFld3 = &test._fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
AdvSimd.LoadVector128((Int64*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<Int64>* pFld2 = &_fld2)
fixed (Vector128<Int64>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
AdvSimd.LoadVector128((Int64*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(&test._fld1)),
AdvSimd.LoadVector128((Int64*)(&test._fld2)),
AdvSimd.LoadVector128((Int64*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.SubtractHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningHighNarrowUpper)}<Int32>(Vector64<Int32>, Vector128<Int64>, Vector128<Int64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractHighNarrowUpper)}<Int32>(Vector64<Int32>, Vector128<Int64>, Vector128<Int64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void AddReturningHighNarrowUpper_Vector128_SByte()
+ private static void SubtractHighNarrowUpper_Vector128_SByte()
{
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_SByte();
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_SByte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_SByte
+ public sealed unsafe class SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_SByte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_SByte testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_SByte testClass)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_SByte testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_SByte testClass)
{
fixed (Vector64<SByte>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
fixed (Vector128<Int16>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
AdvSimd.LoadVector128((Int16*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_SByte()
+ static SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_SByte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<SByte>, byte>(ref _clsVar1), ref Unsafe.As<SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<SByte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar3), ref Unsafe.As<Int16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
}
- public SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_SByte()
+ public SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_SByte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<Int16>* pClsVar2 = &_clsVar2)
fixed (Vector128<Int16>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pClsVar1)),
AdvSimd.LoadVector128((Int16*)(pClsVar2)),
AdvSimd.LoadVector128((Int16*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.AddReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.AddReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_SByte();
- var result = AdvSimd.AddReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_SByte();
+ var result = AdvSimd.SubtractHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_SByte();
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_SByte();
fixed (Vector64<SByte>* pFld1 = &test._fld1)
fixed (Vector128<Int16>* pFld2 = &test._fld2)
fixed (Vector128<Int16>* pFld3 = &test._fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
AdvSimd.LoadVector128((Int16*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<Int16>* pFld2 = &_fld2)
fixed (Vector128<Int16>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
AdvSimd.LoadVector128((Int16*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(&test._fld1)),
AdvSimd.LoadVector128((Int16*)(&test._fld2)),
AdvSimd.LoadVector128((Int16*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.SubtractHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningHighNarrowUpper)}<SByte>(Vector64<SByte>, Vector128<Int16>, Vector128<Int16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractHighNarrowUpper)}<SByte>(Vector64<SByte>, Vector128<Int16>, Vector128<Int16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void AddReturningHighNarrowUpper_Vector128_UInt16()
+ private static void SubtractHighNarrowUpper_Vector128_UInt16()
{
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt16();
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt16
+ public sealed unsafe class SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt16 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt16 testClass)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt16 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt16 testClass)
{
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
fixed (Vector128<UInt32>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
AdvSimd.LoadVector128((UInt32*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt16()
+ static SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar3), ref Unsafe.As<UInt32, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
}
- public SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt16()
+ public SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<UInt32>* pClsVar2 = &_clsVar2)
fixed (Vector128<UInt32>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pClsVar1)),
AdvSimd.LoadVector128((UInt32*)(pClsVar2)),
AdvSimd.LoadVector128((UInt32*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.AddReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.AddReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt16();
- var result = AdvSimd.AddReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt16();
+ var result = AdvSimd.SubtractHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt16();
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt16();
fixed (Vector64<UInt16>* pFld1 = &test._fld1)
fixed (Vector128<UInt32>* pFld2 = &test._fld2)
fixed (Vector128<UInt32>* pFld3 = &test._fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
AdvSimd.LoadVector128((UInt32*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<UInt32>* pFld2 = &_fld2)
fixed (Vector128<UInt32>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
AdvSimd.LoadVector128((UInt32*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(&test._fld1)),
AdvSimd.LoadVector128((UInt32*)(&test._fld2)),
AdvSimd.LoadVector128((UInt32*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.SubtractHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningHighNarrowUpper)}<UInt16>(Vector64<UInt16>, Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractHighNarrowUpper)}<UInt16>(Vector64<UInt16>, Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void AddReturningHighNarrowUpper_Vector128_UInt32()
+ private static void SubtractHighNarrowUpper_Vector128_UInt32()
{
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt32();
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt32
+ public sealed unsafe class SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt32 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt32 testClass)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt32 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt32 testClass)
{
fixed (Vector64<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
fixed (Vector128<UInt64>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
AdvSimd.LoadVector128((UInt64*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt32()
+ static SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt32>, byte>(ref _clsVar1), ref Unsafe.As<UInt32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar3), ref Unsafe.As<UInt64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
}
- public SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt32()
+ public SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<UInt64>* pClsVar2 = &_clsVar2)
fixed (Vector128<UInt64>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pClsVar1)),
AdvSimd.LoadVector128((UInt64*)(pClsVar2)),
AdvSimd.LoadVector128((UInt64*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.AddReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.AddReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt32();
- var result = AdvSimd.AddReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt32();
+ var result = AdvSimd.SubtractHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__AddReturningHighNarrowUpper_Vector128_UInt32();
+ var test = new SimpleTernaryOpTest__SubtractHighNarrowUpper_Vector128_UInt32();
fixed (Vector64<UInt32>* pFld1 = &test._fld1)
fixed (Vector128<UInt64>* pFld2 = &test._fld2)
fixed (Vector128<UInt64>* pFld3 = &test._fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
AdvSimd.LoadVector128((UInt64*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<UInt64>* pFld2 = &_fld2)
fixed (Vector128<UInt64>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
AdvSimd.LoadVector128((UInt64*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.SubtractHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(&test._fld1)),
AdvSimd.LoadVector128((UInt64*)(&test._fld2)),
AdvSimd.LoadVector128((UInt64*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.SubtractHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningHighNarrowUpper)}<UInt32>(Vector64<UInt32>, Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractHighNarrowUpper)}<UInt32>(Vector64<UInt32>, Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void AddReturningRoundedHighNarrowLower_Vector64_Byte()
+ private static void SubtractRoundedHighNarrowLower_Vector64_Byte()
{
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Byte();
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Byte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Byte
+ public sealed unsafe class SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Byte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Byte testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Byte testClass)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Byte testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Byte testClass)
{
fixed (Vector128<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Byte()
+ static SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Byte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar2), ref Unsafe.As<UInt16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
- public SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Byte()
+ public SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Byte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<UInt16>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt16>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pClsVar1)),
AdvSimd.LoadVector128((UInt16*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Byte();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Byte();
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Byte();
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Byte();
fixed (Vector128<UInt16>* pFld1 = &test._fld1)
fixed (Vector128<UInt16>* pFld2 = &test._fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt16*)(&test._fld1)),
AdvSimd.LoadVector128((UInt16*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningRoundedHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.SubtractRoundedHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningRoundedHighNarrowLower)}<Byte>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractRoundedHighNarrowLower)}<Byte>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void AddReturningRoundedHighNarrowLower_Vector64_Int16()
+ private static void SubtractRoundedHighNarrowLower_Vector64_Int16()
{
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int16();
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int16
+ public sealed unsafe class SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int16 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int16 testClass)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int16 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int16 testClass)
{
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int16()
+ static SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar2), ref Unsafe.As<Int32, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
}
- public SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int16()
+ public SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<Int32>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int32>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pClsVar1)),
AdvSimd.LoadVector128((Int32*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int16();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int16();
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int16();
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int16();
fixed (Vector128<Int32>* pFld1 = &test._fld1)
fixed (Vector128<Int32>* pFld2 = &test._fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int32*)(&test._fld1)),
AdvSimd.LoadVector128((Int32*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningRoundedHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.SubtractRoundedHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningRoundedHighNarrowLower)}<Int16>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractRoundedHighNarrowLower)}<Int16>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void AddReturningRoundedHighNarrowLower_Vector64_Int32()
+ private static void SubtractRoundedHighNarrowLower_Vector64_Int32()
{
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int32();
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int32
+ public sealed unsafe class SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int32 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int32 testClass)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int32 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int32 testClass)
{
fixed (Vector128<Int64>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int32()
+ static SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar1), ref Unsafe.As<Int64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar2), ref Unsafe.As<Int64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
}
- public SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int32()
+ public SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<Int64>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pClsVar1)),
AdvSimd.LoadVector128((Int64*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int32();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int32();
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_Int32();
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_Int32();
fixed (Vector128<Int64>* pFld1 = &test._fld1)
fixed (Vector128<Int64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Int64>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int64*)(&test._fld1)),
AdvSimd.LoadVector128((Int64*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningRoundedHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.SubtractRoundedHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningRoundedHighNarrowLower)}<Int32>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractRoundedHighNarrowLower)}<Int32>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void AddReturningRoundedHighNarrowLower_Vector64_SByte()
+ private static void SubtractRoundedHighNarrowLower_Vector64_SByte()
{
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_SByte();
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_SByte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_SByte
+ public sealed unsafe class SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_SByte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_SByte testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_SByte testClass)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_SByte testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_SByte testClass)
{
fixed (Vector128<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_SByte()
+ static SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_SByte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar1), ref Unsafe.As<Int16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar2), ref Unsafe.As<Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
}
- public SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_SByte()
+ public SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_SByte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowLower), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<Int16>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int16>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pClsVar1)),
AdvSimd.LoadVector128((Int16*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_SByte();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_SByte();
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_SByte();
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_SByte();
fixed (Vector128<Int16>* pFld1 = &test._fld1)
fixed (Vector128<Int16>* pFld2 = &test._fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((Int16*)(&test._fld1)),
AdvSimd.LoadVector128((Int16*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningRoundedHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.SubtractRoundedHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningRoundedHighNarrowLower)}<SByte>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractRoundedHighNarrowLower)}<SByte>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void AddReturningRoundedHighNarrowLower_Vector64_UInt16()
+ private static void SubtractRoundedHighNarrowLower_Vector64_UInt16()
{
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt16();
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt16
+ public sealed unsafe class SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt16 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt16 testClass)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt16 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt16 testClass)
{
fixed (Vector128<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt16()
+ static SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar1), ref Unsafe.As<UInt32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar2), ref Unsafe.As<UInt32, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
}
- public SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt16()
+ public SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<UInt32>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt32>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pClsVar1)),
AdvSimd.LoadVector128((UInt32*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt16();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt16();
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt16();
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt16();
fixed (Vector128<UInt32>* pFld1 = &test._fld1)
fixed (Vector128<UInt32>* pFld2 = &test._fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt32*)(&test._fld1)),
AdvSimd.LoadVector128((UInt32*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningRoundedHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.SubtractRoundedHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningRoundedHighNarrowLower)}<UInt16>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractRoundedHighNarrowLower)}<UInt16>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void AddReturningRoundedHighNarrowLower_Vector64_UInt32()
+ private static void SubtractRoundedHighNarrowLower_Vector64_UInt32()
{
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt32();
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt32
+ public sealed unsafe class SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt32 testClass)
+ public void RunStructFldScenario(SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt32 testClass)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt32 testClass)
+ public void RunStructFldScenario_Load(SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt32 testClass)
{
fixed (Vector128<UInt64>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2))
);
private DataTable _dataTable;
- static SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt32()
+ static SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar1), ref Unsafe.As<UInt64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar2), ref Unsafe.As<UInt64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
}
- public SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt32()
+ public SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr)
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowLower), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
_clsVar1,
_clsVar2
);
fixed (Vector128<UInt64>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pClsVar1)),
AdvSimd.LoadVector128((UInt64*)(pClsVar2))
);
var op1 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr);
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(op1, op2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt32();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt32();
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleBinaryOpTest__AddReturningRoundedHighNarrowLower_Vector64_UInt32();
+ var test = new SimpleBinaryOpTest__SubtractRoundedHighNarrowLower_Vector64_UInt32();
fixed (Vector128<UInt64>* pFld1 = &test._fld1)
fixed (Vector128<UInt64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2))
);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(_fld1, _fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
fixed (Vector128<UInt64>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2))
);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(test._fld1, test._fld2);
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowLower(
+ var result = AdvSimd.SubtractRoundedHighNarrowLower(
AdvSimd.LoadVector128((UInt64*)(&test._fld1)),
AdvSimd.LoadVector128((UInt64*)(&test._fld2))
);
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningRoundedHighNarrow(left[i], right[i]) != result[i])
+ if (Helpers.SubtractRoundedHighNarrow(left[i], right[i]) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningRoundedHighNarrowLower)}<UInt32>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractRoundedHighNarrowLower)}<UInt32>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" left: ({string.Join(", ", left)})");
TestLibrary.TestFramework.LogInformation($" right: ({string.Join(", ", right)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
public static partial class Program
{
- private static void AddReturningRoundedHighNarrowUpper_Vector128_Byte()
+ private static void SubtractRoundedHighNarrowUpper_Vector128_Byte()
{
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Byte();
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Byte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Byte
+ public sealed unsafe class SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Byte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Byte testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Byte testClass)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Byte testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Byte testClass)
{
fixed (Vector64<Byte>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
fixed (Vector128<UInt16>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
AdvSimd.LoadVector128((UInt16*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Byte()
+ static SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Byte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _clsVar1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar3), ref Unsafe.As<UInt16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
- public SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Byte()
+ public SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Byte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Byte>), typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<UInt16>* pClsVar2 = &_clsVar2)
fixed (Vector128<UInt16>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pClsVar1)),
AdvSimd.LoadVector128((UInt16*)(pClsVar2)),
AdvSimd.LoadVector128((UInt16*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Byte();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Byte();
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_Byte();
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Byte();
fixed (Vector64<Byte>* pFld1 = &test._fld1)
fixed (Vector128<UInt16>* pFld2 = &test._fld2)
fixed (Vector128<UInt16>* pFld3 = &test._fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
AdvSimd.LoadVector128((UInt16*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<UInt16>* pFld2 = &_fld2)
fixed (Vector128<UInt16>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
AdvSimd.LoadVector128((UInt16*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Byte*)(&test._fld1)),
AdvSimd.LoadVector128((UInt16*)(&test._fld2)),
AdvSimd.LoadVector128((UInt16*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.SubtractRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningRoundedHighNarrowUpper)}<Byte>(Vector64<Byte>, Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractRoundedHighNarrowUpper)}<Byte>(Vector64<Byte>, Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void SubtractReturningHighNarrowUpper_Vector128_Int16()
+ private static void SubtractRoundedHighNarrowUpper_Vector128_Int16()
{
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int16();
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int16
+ public sealed unsafe class SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int16 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int16 testClass)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int16 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int16 testClass)
{
fixed (Vector64<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
fixed (Vector128<Int32>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
AdvSimd.LoadVector128((Int32*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int16()
+ static SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _clsVar1), ref Unsafe.As<Int16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar3), ref Unsafe.As<Int32, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
}
- public SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int16()
+ public SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int16>), typeof(Vector128<Int32>), typeof(Vector128<Int32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<Int32>* pClsVar2 = &_clsVar2)
fixed (Vector128<Int32>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pClsVar1)),
AdvSimd.LoadVector128((Int32*)(pClsVar2)),
AdvSimd.LoadVector128((Int32*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.SubtractReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int16();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int16();
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int16();
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int16();
fixed (Vector64<Int16>* pFld1 = &test._fld1)
fixed (Vector128<Int32>* pFld2 = &test._fld2)
fixed (Vector128<Int32>* pFld3 = &test._fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
AdvSimd.LoadVector128((Int32*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<Int32>* pFld2 = &_fld2)
fixed (Vector128<Int32>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
AdvSimd.LoadVector128((Int32*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int16*)(&test._fld1)),
AdvSimd.LoadVector128((Int32*)(&test._fld2)),
AdvSimd.LoadVector128((Int32*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.SubtractRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningHighNarrowUpper)}<Int16>(Vector64<Int16>, Vector128<Int32>, Vector128<Int32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractRoundedHighNarrowUpper)}<Int16>(Vector64<Int16>, Vector128<Int32>, Vector128<Int32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void SubtractReturningHighNarrowUpper_Vector128_Int32()
+ private static void SubtractRoundedHighNarrowUpper_Vector128_Int32()
{
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int32();
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int32
+ public sealed unsafe class SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int32 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int32 testClass)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int32 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int32 testClass)
{
fixed (Vector64<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
fixed (Vector128<Int64>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
AdvSimd.LoadVector128((Int64*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int32()
+ static SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int32>, byte>(ref _clsVar1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Int32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar3), ref Unsafe.As<Int64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
}
- public SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int32()
+ public SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowUpper), new Type[] { typeof(Vector64<Int32>), typeof(Vector128<Int64>), typeof(Vector128<Int64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<Int64>* pClsVar2 = &_clsVar2)
fixed (Vector128<Int64>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pClsVar1)),
AdvSimd.LoadVector128((Int64*)(pClsVar2)),
AdvSimd.LoadVector128((Int64*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.SubtractReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int32();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int32();
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_Int32();
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_Int32();
fixed (Vector64<Int32>* pFld1 = &test._fld1)
fixed (Vector128<Int64>* pFld2 = &test._fld2)
fixed (Vector128<Int64>* pFld3 = &test._fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
AdvSimd.LoadVector128((Int64*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<Int64>* pFld2 = &_fld2)
fixed (Vector128<Int64>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
AdvSimd.LoadVector128((Int64*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((Int32*)(&test._fld1)),
AdvSimd.LoadVector128((Int64*)(&test._fld2)),
AdvSimd.LoadVector128((Int64*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.SubtractRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningHighNarrowUpper)}<Int32>(Vector64<Int32>, Vector128<Int64>, Vector128<Int64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractRoundedHighNarrowUpper)}<Int32>(Vector64<Int32>, Vector128<Int64>, Vector128<Int64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void SubtractReturningHighNarrowUpper_Vector128_SByte()
+ private static void SubtractRoundedHighNarrowUpper_Vector128_SByte()
{
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_SByte();
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_SByte();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_SByte
+ public sealed unsafe class SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_SByte
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_SByte testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_SByte testClass)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_SByte testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_SByte testClass)
{
fixed (Vector64<SByte>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
fixed (Vector128<Int16>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
AdvSimd.LoadVector128((Int16*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_SByte()
+ static SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_SByte()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<SByte>, byte>(ref _clsVar1), ref Unsafe.As<SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<SByte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar3), ref Unsafe.As<Int16, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
}
- public SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_SByte()
+ public SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_SByte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractReturningHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowUpper), new Type[] { typeof(Vector64<SByte>), typeof(Vector128<Int16>), typeof(Vector128<Int16>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<Int16>* pClsVar2 = &_clsVar2)
fixed (Vector128<Int16>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pClsVar1)),
AdvSimd.LoadVector128((Int16*)(pClsVar2)),
AdvSimd.LoadVector128((Int16*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.SubtractReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_SByte();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_SByte();
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__SubtractReturningHighNarrowUpper_Vector128_SByte();
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_SByte();
fixed (Vector64<SByte>* pFld1 = &test._fld1)
fixed (Vector128<Int16>* pFld2 = &test._fld2)
fixed (Vector128<Int16>* pFld3 = &test._fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
AdvSimd.LoadVector128((Int16*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.SubtractReturningHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<Int16>* pFld2 = &_fld2)
fixed (Vector128<Int16>* pFld3 = &_fld3)
{
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
AdvSimd.LoadVector128((Int16*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.SubtractReturningHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((SByte*)(&test._fld1)),
AdvSimd.LoadVector128((Int16*)(&test._fld2)),
AdvSimd.LoadVector128((Int16*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.SubtractReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.SubtractRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractReturningHighNarrowUpper)}<SByte>(Vector64<SByte>, Vector128<Int16>, Vector128<Int16>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractRoundedHighNarrowUpper)}<SByte>(Vector64<SByte>, Vector128<Int16>, Vector128<Int16>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void AddReturningRoundedHighNarrowUpper_Vector128_UInt16()
+ private static void SubtractRoundedHighNarrowUpper_Vector128_UInt16()
{
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt16();
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt16();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt16
+ public sealed unsafe class SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt16
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt16 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt16 testClass)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt16 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt16 testClass)
{
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
fixed (Vector128<UInt32>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
AdvSimd.LoadVector128((UInt32*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt16()
+ static SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt16()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar3), ref Unsafe.As<UInt32, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
}
- public SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt16()
+ public SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt16>), typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<UInt32>* pClsVar2 = &_clsVar2)
fixed (Vector128<UInt32>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pClsVar1)),
AdvSimd.LoadVector128((UInt32*)(pClsVar2)),
AdvSimd.LoadVector128((UInt32*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt16();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt16();
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt16();
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt16();
fixed (Vector64<UInt16>* pFld1 = &test._fld1)
fixed (Vector128<UInt32>* pFld2 = &test._fld2)
fixed (Vector128<UInt32>* pFld3 = &test._fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
AdvSimd.LoadVector128((UInt32*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<UInt32>* pFld2 = &_fld2)
fixed (Vector128<UInt32>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
AdvSimd.LoadVector128((UInt32*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt16*)(&test._fld1)),
AdvSimd.LoadVector128((UInt32*)(&test._fld2)),
AdvSimd.LoadVector128((UInt32*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.SubtractRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningRoundedHighNarrowUpper)}<UInt16>(Vector64<UInt16>, Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractRoundedHighNarrowUpper)}<UInt16>(Vector64<UInt16>, Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
{
public static partial class Program
{
- private static void AddReturningRoundedHighNarrowUpper_Vector128_UInt32()
+ private static void SubtractRoundedHighNarrowUpper_Vector128_UInt32()
{
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt32();
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt32();
if (test.IsSupported)
{
}
}
- public sealed unsafe class SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt32
+ public sealed unsafe class SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt32
{
private struct DataTable
{
return testStruct;
}
- public void RunStructFldScenario(SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt32 testClass)
+ public void RunStructFldScenario(SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt32 testClass)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
- public void RunStructFldScenario_Load(SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt32 testClass)
+ public void RunStructFldScenario_Load(SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt32 testClass)
{
fixed (Vector64<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
fixed (Vector128<UInt64>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
AdvSimd.LoadVector128((UInt64*)(pFld3))
private DataTable _dataTable;
- static SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt32()
+ static SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt32()
{
for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); }
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt32>, byte>(ref _clsVar1), ref Unsafe.As<UInt32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar3), ref Unsafe.As<UInt64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
}
- public SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt32()
+ public SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray3Ptr)
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray3Ptr))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.AddReturningRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.SubtractRoundedHighNarrowUpper), new Type[] { typeof(Vector64<UInt32>), typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
_clsVar1,
_clsVar2,
_clsVar3
fixed (Vector128<UInt64>* pClsVar2 = &_clsVar2)
fixed (Vector128<UInt64>* pClsVar3 = &_clsVar3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pClsVar1)),
AdvSimd.LoadVector128((UInt64*)(pClsVar2)),
AdvSimd.LoadVector128((UInt64*)(pClsVar3))
var op1 = Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr);
var op3 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray3Ptr);
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
var op1 = AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr));
var op2 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr));
var op3 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray3Ptr));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(op1, op2, op3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(op1, op2, op3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt32();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt32();
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
- var test = new SimpleTernaryOpTest__AddReturningRoundedHighNarrowUpper_Vector128_UInt32();
+ var test = new SimpleTernaryOpTest__SubtractRoundedHighNarrowUpper_Vector128_UInt32();
fixed (Vector64<UInt32>* pFld1 = &test._fld1)
fixed (Vector128<UInt64>* pFld2 = &test._fld2)
fixed (Vector128<UInt64>* pFld3 = &test._fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
AdvSimd.LoadVector128((UInt64*)(pFld3))
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(_fld1, _fld2, _fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
fixed (Vector128<UInt64>* pFld2 = &_fld2)
fixed (Vector128<UInt64>* pFld3 = &_fld3)
{
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
AdvSimd.LoadVector128((UInt64*)(pFld3))
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(test._fld1, test._fld2, test._fld3);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
- var result = AdvSimd.AddReturningRoundedHighNarrowUpper(
+ var result = AdvSimd.SubtractRoundedHighNarrowUpper(
AdvSimd.LoadVector64((UInt32*)(&test._fld1)),
AdvSimd.LoadVector128((UInt64*)(&test._fld2)),
AdvSimd.LoadVector128((UInt64*)(&test._fld3))
for (var i = 0; i < RetElementCount; i++)
{
- if (Helpers.AddReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
+ if (Helpers.SubtractRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i])
{
succeeded = false;
break;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.AddReturningRoundedHighNarrowUpper)}<UInt32>(Vector64<UInt32>, Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.SubtractRoundedHighNarrowUpper)}<UInt32>(Vector64<UInt32>, Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})");
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "Add_Vector128_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "Add", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.Add(left[i], right[i]) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "Add_Vector128_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "Add", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.Add(left[i], right[i]) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "Add_Vector128_UInt64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "Add", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.Add(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddHighNarrowLower_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.AddHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddHighNarrowLower_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.AddHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddHighNarrowLower_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.AddHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddHighNarrowLower_Vector64_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.AddHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddHighNarrowLower_Vector64_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.AddHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddHighNarrowLower_Vector64_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.AddHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddHighNarrowUpper_Vector128_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.AddHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddHighNarrowUpper_Vector128_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.AddHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddHighNarrowUpper_Vector128_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.AddHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddHighNarrowUpper_Vector128_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.AddHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddHighNarrowUpper_Vector128_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.AddHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddHighNarrowUpper_Vector128_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.AddHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddPairwise_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddPairwise", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "Helpers.AddPairwise(left, right, i) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddPairwise_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddPairwise", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.AddPairwise(left, right, i) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddPairwise_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddPairwise", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.AddPairwise(left, right, i) != result[i]"}),
("SimpleBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddPairwiseWideningAndAddScalar_Vector64_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddPairwiseWideningAndAddScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "Helpers.AddPairwiseWideningAndAdd(left, right, 0) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}),
("SimpleUnOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddPairwiseWideningScalar_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddPairwiseWideningScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "Helpers.AddPairwiseWidening(firstOp, 0) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}),
("SimpleUnOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddPairwiseWideningScalar_Vector64_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddPairwiseWideningScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "Helpers.AddPairwiseWidening(firstOp, 0) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningHighNarrowLower_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.AddReturningHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningHighNarrowLower_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.AddReturningHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningHighNarrowLower_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.AddReturningHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningHighNarrowLower_Vector64_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.AddReturningHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningHighNarrowLower_Vector64_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.AddReturningHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningHighNarrowLower_Vector64_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.AddReturningHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningHighNarrowUpper_Vector128_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.AddReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningHighNarrowUpper_Vector128_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.AddReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningHighNarrowUpper_Vector128_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.AddReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningHighNarrowUpper_Vector128_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.AddReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningHighNarrowUpper_Vector128_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.AddReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningHighNarrowUpper_Vector128_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.AddReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningRoundedHighNarrowLower_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.AddReturningRoundedHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningRoundedHighNarrowLower_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.AddReturningRoundedHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningRoundedHighNarrowLower_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.AddReturningRoundedHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningRoundedHighNarrowLower_Vector64_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.AddReturningRoundedHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningRoundedHighNarrowLower_Vector64_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.AddReturningRoundedHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningRoundedHighNarrowLower_Vector64_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.AddReturningRoundedHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningRoundedHighNarrowUpper_Vector128_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.AddReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningRoundedHighNarrowUpper_Vector128_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.AddReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningRoundedHighNarrowUpper_Vector128_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.AddReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningRoundedHighNarrowUpper_Vector128_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.AddReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningRoundedHighNarrowUpper_Vector128_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.AddReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddReturningRoundedHighNarrowUpper_Vector128_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddReturningRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.AddReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddRoundedHighNarrowLower_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.AddRoundedHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddRoundedHighNarrowLower_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.AddRoundedHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddRoundedHighNarrowLower_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.AddRoundedHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddRoundedHighNarrowLower_Vector64_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.AddRoundedHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddRoundedHighNarrowLower_Vector64_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.AddRoundedHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddRoundedHighNarrowLower_Vector64_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.AddRoundedHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddRoundedHighNarrowUpper_Vector128_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.AddRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddRoundedHighNarrowUpper_Vector128_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.AddRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddRoundedHighNarrowUpper_Vector128_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.AddRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddRoundedHighNarrowUpper_Vector128_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.AddRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddRoundedHighNarrowUpper_Vector128_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.AddRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddRoundedHighNarrowUpper_Vector128_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.AddRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddSaturate_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddSaturate", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "Helpers.AddSaturate(left[i], right[i]) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddSaturate_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddSaturate", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.AddSaturate(left[i], right[i]) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "AddSaturate_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "AddSaturate", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.AddSaturate(left[i], right[i]) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "Subtract_Vector128_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "Subtract", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.Subtract(left[i], right[i]) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "Subtract_Vector128_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "Subtract", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.Subtract(left[i], right[i]) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "Subtract_Vector128_UInt64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "Subtract", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.Subtract(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningHighNarrowLower_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.SubtractReturningHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningHighNarrowLower_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.SubtractReturningHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningHighNarrowLower_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.SubtractReturningHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningHighNarrowLower_Vector64_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.SubtractReturningHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningHighNarrowLower_Vector64_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.SubtractReturningHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningHighNarrowLower_Vector64_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.SubtractReturningHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningHighNarrowUpper_Vector128_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.SubtractReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningHighNarrowUpper_Vector128_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.SubtractReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningHighNarrowUpper_Vector128_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.SubtractReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningHighNarrowUpper_Vector128_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.SubtractReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningHighNarrowUpper_Vector128_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.SubtractReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningHighNarrowUpper_Vector128_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.SubtractReturningHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningRoundedHighNarrowLower_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.SubtractReturningRoundedHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningRoundedHighNarrowLower_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.SubtractReturningRoundedHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningRoundedHighNarrowLower_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.SubtractReturningRoundedHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningRoundedHighNarrowLower_Vector64_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.SubtractReturningRoundedHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningRoundedHighNarrowLower_Vector64_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.SubtractReturningRoundedHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningRoundedHighNarrowLower_Vector64_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.SubtractReturningRoundedHighNarrow(left[i], right[i]) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningRoundedHighNarrowUpper_Vector128_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.SubtractReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningRoundedHighNarrowUpper_Vector128_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.SubtractReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningRoundedHighNarrowUpper_Vector128_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.SubtractReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningRoundedHighNarrowUpper_Vector128_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.SubtractReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningRoundedHighNarrowUpper_Vector128_UInt16",["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.SubtractReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
- ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractReturningRoundedHighNarrowUpper_Vector128_UInt32",["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractReturningRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.SubtractReturningRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractHighNarrowLower_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.SubtractHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractHighNarrowLower_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.SubtractHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractHighNarrowLower_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.SubtractHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractHighNarrowLower_Vector64_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.SubtractHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractHighNarrowLower_Vector64_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.SubtractHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractHighNarrowLower_Vector64_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.SubtractHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractHighNarrowUpper_Vector128_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.SubtractHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractHighNarrowUpper_Vector128_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.SubtractHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractHighNarrowUpper_Vector128_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.SubtractHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractHighNarrowUpper_Vector128_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.SubtractHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractHighNarrowUpper_Vector128_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.SubtractHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractHighNarrowUpper_Vector128_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.SubtractHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractRoundedHighNarrowLower_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.SubtractRoundedHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractRoundedHighNarrowLower_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.SubtractRoundedHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractRoundedHighNarrowLower_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.SubtractRoundedHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractRoundedHighNarrowLower_Vector64_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.SubtractRoundedHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractRoundedHighNarrowLower_Vector64_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.SubtractRoundedHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractRoundedHighNarrowLower_Vector64_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractRoundedHighNarrowLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.SubtractRoundedHighNarrow(left[i], right[i]) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractRoundedHighNarrowUpper_Vector128_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.SubtractRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractRoundedHighNarrowUpper_Vector128_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.SubtractRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractRoundedHighNarrowUpper_Vector128_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.SubtractRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractRoundedHighNarrowUpper_Vector128_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.SubtractRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractRoundedHighNarrowUpper_Vector128_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.SubtractRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
+ ("VecTernOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractRoundedHighNarrowUpper_Vector128_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractRoundedHighNarrowUpper", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.SubtractRoundedHighNarrowUpper(firstOp, secondOp, thirdOp, i) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractSaturate_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractSaturate", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "Helpers.SubtractSaturate(left[i], right[i]) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractSaturate_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractSaturate", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.SubtractSaturate(left[i], right[i]) != result[i]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["TestName"] = "SubtractSaturate_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractSaturate", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.SubtractSaturate(left[i], right[i]) != result[i]"}),
return (sbyte)(((ushort)op1 + roundConst) >> (8 * sizeof(sbyte)));
}
- public static sbyte AddReturningHighNarrow(short op1, short op2) => HighNarrow((short)(op1 + op2), round: false);
+ public static sbyte AddHighNarrow(short op1, short op2) => HighNarrow((short)(op1 + op2), round: false);
- public static sbyte AddReturningHighNarrowUpper(sbyte[] op1, short[] op2, short[] op3, int i) => i < op1.Length ? op1[i] : AddReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static sbyte AddHighNarrowUpper(sbyte[] op1, short[] op2, short[] op3, int i) => i < op1.Length ? op1[i] : AddHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static sbyte AddReturningRoundedHighNarrow(short op1, short op2) => HighNarrow((short)(op1 + op2), round: true);
+ public static sbyte AddRoundedHighNarrow(short op1, short op2) => HighNarrow((short)(op1 + op2), round: true);
- public static short AddReturningRoundedHighNarrowUpper(sbyte[] op1, short[] op2, short[] op3, int i) => i < op1.Length ? op1[i] : AddReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static short AddRoundedHighNarrowUpper(sbyte[] op1, short[] op2, short[] op3, int i) => i < op1.Length ? op1[i] : AddRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static short AddWidening(sbyte op1, sbyte op2) => (short)((short)op1 + (short)op2);
public static short MultiplyWideningUpperAndSubtract(short[] op1, sbyte[] op2, sbyte[] op3, int i) => MultiplyWideningAndSubtract(op1[i], op2[i + op2.Length / 2], op3[i + op3.Length / 2]);
- public static sbyte SubtractReturningHighNarrow(short op1, short op2) => HighNarrow((short)(op1 - op2), round: false);
+ public static sbyte SubtractHighNarrow(short op1, short op2) => HighNarrow((short)(op1 - op2), round: false);
- public static short SubtractReturningHighNarrowUpper(sbyte[] op1, short[] op2, short[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static short SubtractHighNarrowUpper(sbyte[] op1, short[] op2, short[] op3, int i) => i < op1.Length ? op1[i] : SubtractHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static sbyte SubtractReturningRoundedHighNarrow(short op1, short op2) => HighNarrow((short)(op1 - op2), round: true);
+ public static sbyte SubtractRoundedHighNarrow(short op1, short op2) => HighNarrow((short)(op1 - op2), round: true);
- public static short SubtractReturningRoundedHighNarrowUpper(sbyte[] op1, short[] op2, short[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static short SubtractRoundedHighNarrowUpper(sbyte[] op1, short[] op2, short[] op3, int i) => i < op1.Length ? op1[i] : SubtractRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static short SubtractWidening(sbyte op1, sbyte op2) => (short)((short)op1 - (short)op2);
return (short)(((uint)op1 + roundConst) >> (8 * sizeof(short)));
}
- public static short AddReturningHighNarrow(int op1, int op2) => HighNarrow((int)(op1 + op2), round: false);
+ public static short AddHighNarrow(int op1, int op2) => HighNarrow((int)(op1 + op2), round: false);
- public static short AddReturningHighNarrowUpper(short[] op1, int[] op2, int[] op3, int i) => i < op1.Length ? op1[i] : AddReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static short AddHighNarrowUpper(short[] op1, int[] op2, int[] op3, int i) => i < op1.Length ? op1[i] : AddHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static short AddReturningRoundedHighNarrow(int op1, int op2) => HighNarrow((int)(op1 + op2), round: true);
+ public static short AddRoundedHighNarrow(int op1, int op2) => HighNarrow((int)(op1 + op2), round: true);
- public static int AddReturningRoundedHighNarrowUpper(short[] op1, int[] op2, int[] op3, int i) => i < op1.Length ? op1[i] : AddReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static int AddRoundedHighNarrowUpper(short[] op1, int[] op2, int[] op3, int i) => i < op1.Length ? op1[i] : AddRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static int AddWidening(short op1, short op2) => (int)((int)op1 + (int)op2);
public static int MultiplyWideningUpperAndSubtract(int[] op1, short[] op2, short[] op3, int i) => MultiplyWideningAndSubtract(op1[i], op2[i + op2.Length / 2], op3[i + op3.Length / 2]);
- public static short SubtractReturningHighNarrow(int op1, int op2) => HighNarrow((int)(op1 - op2), round: false);
+ public static short SubtractHighNarrow(int op1, int op2) => HighNarrow((int)(op1 - op2), round: false);
- public static int SubtractReturningHighNarrowUpper(short[] op1, int[] op2, int[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static int SubtractHighNarrowUpper(short[] op1, int[] op2, int[] op3, int i) => i < op1.Length ? op1[i] : SubtractHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static short SubtractReturningRoundedHighNarrow(int op1, int op2) => HighNarrow((int)(op1 - op2), round: true);
+ public static short SubtractRoundedHighNarrow(int op1, int op2) => HighNarrow((int)(op1 - op2), round: true);
- public static int SubtractReturningRoundedHighNarrowUpper(short[] op1, int[] op2, int[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static int SubtractRoundedHighNarrowUpper(short[] op1, int[] op2, int[] op3, int i) => i < op1.Length ? op1[i] : SubtractRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static int SubtractWidening(short op1, short op2) => (int)((int)op1 - (int)op2);
return (int)(((ulong)op1 + roundConst) >> (8 * sizeof(int)));
}
- public static int AddReturningHighNarrow(long op1, long op2) => HighNarrow((long)(op1 + op2), round: false);
+ public static int AddHighNarrow(long op1, long op2) => HighNarrow((long)(op1 + op2), round: false);
- public static int AddReturningHighNarrowUpper(int[] op1, long[] op2, long[] op3, int i) => i < op1.Length ? op1[i] : AddReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static int AddHighNarrowUpper(int[] op1, long[] op2, long[] op3, int i) => i < op1.Length ? op1[i] : AddHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static int AddReturningRoundedHighNarrow(long op1, long op2) => HighNarrow((long)(op1 + op2), round: true);
+ public static int AddRoundedHighNarrow(long op1, long op2) => HighNarrow((long)(op1 + op2), round: true);
- public static long AddReturningRoundedHighNarrowUpper(int[] op1, long[] op2, long[] op3, int i) => i < op1.Length ? op1[i] : AddReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static long AddRoundedHighNarrowUpper(int[] op1, long[] op2, long[] op3, int i) => i < op1.Length ? op1[i] : AddRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static long AddWidening(int op1, int op2) => (long)((long)op1 + (long)op2);
public static long MultiplyWideningUpperAndSubtract(long[] op1, int[] op2, int[] op3, int i) => MultiplyWideningAndSubtract(op1[i], op2[i + op2.Length / 2], op3[i + op3.Length / 2]);
- public static int SubtractReturningHighNarrow(long op1, long op2) => HighNarrow((long)(op1 - op2), round: false);
+ public static int SubtractHighNarrow(long op1, long op2) => HighNarrow((long)(op1 - op2), round: false);
- public static long SubtractReturningHighNarrowUpper(int[] op1, long[] op2, long[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static long SubtractHighNarrowUpper(int[] op1, long[] op2, long[] op3, int i) => i < op1.Length ? op1[i] : SubtractHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static int SubtractReturningRoundedHighNarrow(long op1, long op2) => HighNarrow((long)(op1 - op2), round: true);
+ public static int SubtractRoundedHighNarrow(long op1, long op2) => HighNarrow((long)(op1 - op2), round: true);
- public static long SubtractReturningRoundedHighNarrowUpper(int[] op1, long[] op2, long[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static long SubtractRoundedHighNarrowUpper(int[] op1, long[] op2, long[] op3, int i) => i < op1.Length ? op1[i] : SubtractRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static long SubtractWidening(int op1, int op2) => (long)((long)op1 - (long)op2);
return (byte)(((ushort)op1 + roundConst) >> (8 * sizeof(byte)));
}
- public static byte AddReturningHighNarrow(ushort op1, ushort op2) => HighNarrow((ushort)(op1 + op2), round: false);
+ public static byte AddHighNarrow(ushort op1, ushort op2) => HighNarrow((ushort)(op1 + op2), round: false);
- public static byte AddReturningHighNarrowUpper(byte[] op1, ushort[] op2, ushort[] op3, int i) => i < op1.Length ? op1[i] : AddReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static byte AddHighNarrowUpper(byte[] op1, ushort[] op2, ushort[] op3, int i) => i < op1.Length ? op1[i] : AddHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static byte AddReturningRoundedHighNarrow(ushort op1, ushort op2) => HighNarrow((ushort)(op1 + op2), round: true);
+ public static byte AddRoundedHighNarrow(ushort op1, ushort op2) => HighNarrow((ushort)(op1 + op2), round: true);
- public static ushort AddReturningRoundedHighNarrowUpper(byte[] op1, ushort[] op2, ushort[] op3, int i) => i < op1.Length ? op1[i] : AddReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static ushort AddRoundedHighNarrowUpper(byte[] op1, ushort[] op2, ushort[] op3, int i) => i < op1.Length ? op1[i] : AddRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static ushort AddWidening(byte op1, byte op2) => (ushort)((ushort)op1 + (ushort)op2);
public static ushort MultiplyWideningUpperAndSubtract(ushort[] op1, byte[] op2, byte[] op3, int i) => MultiplyWideningAndSubtract(op1[i], op2[i + op2.Length / 2], op3[i + op3.Length / 2]);
- public static byte SubtractReturningHighNarrow(ushort op1, ushort op2) => HighNarrow((ushort)(op1 - op2), round: false);
+ public static byte SubtractHighNarrow(ushort op1, ushort op2) => HighNarrow((ushort)(op1 - op2), round: false);
- public static ushort SubtractReturningHighNarrowUpper(byte[] op1, ushort[] op2, ushort[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static ushort SubtractHighNarrowUpper(byte[] op1, ushort[] op2, ushort[] op3, int i) => i < op1.Length ? op1[i] : SubtractHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static byte SubtractReturningRoundedHighNarrow(ushort op1, ushort op2) => HighNarrow((ushort)(op1 - op2), round: true);
+ public static byte SubtractRoundedHighNarrow(ushort op1, ushort op2) => HighNarrow((ushort)(op1 - op2), round: true);
- public static ushort SubtractReturningRoundedHighNarrowUpper(byte[] op1, ushort[] op2, ushort[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static ushort SubtractRoundedHighNarrowUpper(byte[] op1, ushort[] op2, ushort[] op3, int i) => i < op1.Length ? op1[i] : SubtractRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static ushort SubtractWidening(byte op1, byte op2) => (ushort)((ushort)op1 - (ushort)op2);
return (ushort)(((uint)op1 + roundConst) >> (8 * sizeof(ushort)));
}
- public static ushort AddReturningHighNarrow(uint op1, uint op2) => HighNarrow((uint)(op1 + op2), round: false);
+ public static ushort AddHighNarrow(uint op1, uint op2) => HighNarrow((uint)(op1 + op2), round: false);
- public static ushort AddReturningHighNarrowUpper(ushort[] op1, uint[] op2, uint[] op3, int i) => i < op1.Length ? op1[i] : AddReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static ushort AddHighNarrowUpper(ushort[] op1, uint[] op2, uint[] op3, int i) => i < op1.Length ? op1[i] : AddHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static ushort AddReturningRoundedHighNarrow(uint op1, uint op2) => HighNarrow((uint)(op1 + op2), round: true);
+ public static ushort AddRoundedHighNarrow(uint op1, uint op2) => HighNarrow((uint)(op1 + op2), round: true);
- public static uint AddReturningRoundedHighNarrowUpper(ushort[] op1, uint[] op2, uint[] op3, int i) => i < op1.Length ? op1[i] : AddReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static uint AddRoundedHighNarrowUpper(ushort[] op1, uint[] op2, uint[] op3, int i) => i < op1.Length ? op1[i] : AddRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static uint AddWidening(ushort op1, ushort op2) => (uint)((uint)op1 + (uint)op2);
public static uint MultiplyWideningUpperAndSubtract(uint[] op1, ushort[] op2, ushort[] op3, int i) => MultiplyWideningAndSubtract(op1[i], op2[i + op2.Length / 2], op3[i + op3.Length / 2]);
- public static ushort SubtractReturningHighNarrow(uint op1, uint op2) => HighNarrow((uint)(op1 - op2), round: false);
+ public static ushort SubtractHighNarrow(uint op1, uint op2) => HighNarrow((uint)(op1 - op2), round: false);
- public static uint SubtractReturningHighNarrowUpper(ushort[] op1, uint[] op2, uint[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static uint SubtractHighNarrowUpper(ushort[] op1, uint[] op2, uint[] op3, int i) => i < op1.Length ? op1[i] : SubtractHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static ushort SubtractReturningRoundedHighNarrow(uint op1, uint op2) => HighNarrow((uint)(op1 - op2), round: true);
+ public static ushort SubtractRoundedHighNarrow(uint op1, uint op2) => HighNarrow((uint)(op1 - op2), round: true);
- public static uint SubtractReturningRoundedHighNarrowUpper(ushort[] op1, uint[] op2, uint[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static uint SubtractRoundedHighNarrowUpper(ushort[] op1, uint[] op2, uint[] op3, int i) => i < op1.Length ? op1[i] : SubtractRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static uint SubtractWidening(ushort op1, ushort op2) => (uint)((uint)op1 - (uint)op2);
return (uint)(((ulong)op1 + roundConst) >> (8 * sizeof(uint)));
}
- public static uint AddReturningHighNarrow(ulong op1, ulong op2) => HighNarrow((ulong)(op1 + op2), round: false);
+ public static uint AddHighNarrow(ulong op1, ulong op2) => HighNarrow((ulong)(op1 + op2), round: false);
- public static uint AddReturningHighNarrowUpper(uint[] op1, ulong[] op2, ulong[] op3, int i) => i < op1.Length ? op1[i] : AddReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static uint AddHighNarrowUpper(uint[] op1, ulong[] op2, ulong[] op3, int i) => i < op1.Length ? op1[i] : AddHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static uint AddReturningRoundedHighNarrow(ulong op1, ulong op2) => HighNarrow((ulong)(op1 + op2), round: true);
+ public static uint AddRoundedHighNarrow(ulong op1, ulong op2) => HighNarrow((ulong)(op1 + op2), round: true);
- public static ulong AddReturningRoundedHighNarrowUpper(uint[] op1, ulong[] op2, ulong[] op3, int i) => i < op1.Length ? op1[i] : AddReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static ulong AddRoundedHighNarrowUpper(uint[] op1, ulong[] op2, ulong[] op3, int i) => i < op1.Length ? op1[i] : AddRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static ulong AddWidening(uint op1, uint op2) => (ulong)((ulong)op1 + (ulong)op2);
public static ulong MultiplyWideningUpperAndSubtract(ulong[] op1, uint[] op2, uint[] op3, int i) => MultiplyWideningAndSubtract(op1[i], op2[i + op2.Length / 2], op3[i + op3.Length / 2]);
- public static uint SubtractReturningHighNarrow(ulong op1, ulong op2) => HighNarrow((ulong)(op1 - op2), round: false);
+ public static uint SubtractHighNarrow(ulong op1, ulong op2) => HighNarrow((ulong)(op1 - op2), round: false);
- public static ulong SubtractReturningHighNarrowUpper(uint[] op1, ulong[] op2, ulong[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static ulong SubtractHighNarrowUpper(uint[] op1, ulong[] op2, ulong[] op3, int i) => i < op1.Length ? op1[i] : SubtractHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static uint SubtractReturningRoundedHighNarrow(ulong op1, ulong op2) => HighNarrow((ulong)(op1 - op2), round: true);
+ public static uint SubtractRoundedHighNarrow(ulong op1, ulong op2) => HighNarrow((ulong)(op1 - op2), round: true);
- public static ulong SubtractReturningRoundedHighNarrowUpper(uint[] op1, ulong[] op2, ulong[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static ulong SubtractRoundedHighNarrowUpper(uint[] op1, ulong[] op2, ulong[] op3, int i) => i < op1.Length ? op1[i] : SubtractRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static ulong SubtractWidening(uint op1, uint op2) => (ulong)((ulong)op1 - (ulong)op2);
return (<#= type.name #>)(((<#= type.wideUnsigned #>)op1 + roundConst) >> (8 * sizeof(<#= type.name #>)));
}
- public static <#= type.name #> AddReturningHighNarrow(<#= type.wide #> op1, <#= type.wide #> op2) => HighNarrow((<#= type.wide #>)(op1 + op2), round: false);
+ public static <#= type.name #> AddHighNarrow(<#= type.wide #> op1, <#= type.wide #> op2) => HighNarrow((<#= type.wide #>)(op1 + op2), round: false);
- public static <#= type.name #> AddReturningHighNarrowUpper(<#= type.name #>[] op1, <#= type.wide #>[] op2, <#= type.wide #>[] op3, int i) => i < op1.Length ? op1[i] : AddReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static <#= type.name #> AddHighNarrowUpper(<#= type.name #>[] op1, <#= type.wide #>[] op2, <#= type.wide #>[] op3, int i) => i < op1.Length ? op1[i] : AddHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static <#= type.name #> AddReturningRoundedHighNarrow(<#= type.wide #> op1, <#= type.wide #> op2) => HighNarrow((<#= type.wide #>)(op1 + op2), round: true);
+ public static <#= type.name #> AddRoundedHighNarrow(<#= type.wide #> op1, <#= type.wide #> op2) => HighNarrow((<#= type.wide #>)(op1 + op2), round: true);
- public static <#= type.wide #> AddReturningRoundedHighNarrowUpper(<#= type.name #>[] op1, <#= type.wide #>[] op2, <#= type.wide #>[] op3, int i) => i < op1.Length ? op1[i] : AddReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static <#= type.wide #> AddRoundedHighNarrowUpper(<#= type.name #>[] op1, <#= type.wide #>[] op2, <#= type.wide #>[] op3, int i) => i < op1.Length ? op1[i] : AddRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static <#= type.wide #> AddWidening(<#= type.name #> op1, <#= type.name #> op2) => (<#= type.wide #>)((<#= type.wide #>)op1 + (<#= type.wide #>)op2);
public static <#= type.wide #> MultiplyWideningUpperAndSubtract(<#= type.wide #>[] op1, <#= type.name #>[] op2, <#= type.name #>[] op3, int i) => MultiplyWideningAndSubtract(op1[i], op2[i + op2.Length / 2], op3[i + op3.Length / 2]);
- public static <#= type.name #> SubtractReturningHighNarrow(<#= type.wide #> op1, <#= type.wide #> op2) => HighNarrow((<#= type.wide #>)(op1 - op2), round: false);
+ public static <#= type.name #> SubtractHighNarrow(<#= type.wide #> op1, <#= type.wide #> op2) => HighNarrow((<#= type.wide #>)(op1 - op2), round: false);
- public static <#= type.wide #> SubtractReturningHighNarrowUpper(<#= type.name #>[] op1, <#= type.wide #>[] op2, <#= type.wide #>[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static <#= type.wide #> SubtractHighNarrowUpper(<#= type.name #>[] op1, <#= type.wide #>[] op2, <#= type.wide #>[] op3, int i) => i < op1.Length ? op1[i] : SubtractHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
- public static <#= type.name #> SubtractReturningRoundedHighNarrow(<#= type.wide #> op1, <#= type.wide #> op2) => HighNarrow((<#= type.wide #>)(op1 - op2), round: true);
+ public static <#= type.name #> SubtractRoundedHighNarrow(<#= type.wide #> op1, <#= type.wide #> op2) => HighNarrow((<#= type.wide #>)(op1 - op2), round: true);
- public static <#= type.wide #> SubtractReturningRoundedHighNarrowUpper(<#= type.name #>[] op1, <#= type.wide #>[] op2, <#= type.wide #>[] op3, int i) => i < op1.Length ? op1[i] : SubtractReturningRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
+ public static <#= type.wide #> SubtractRoundedHighNarrowUpper(<#= type.name #>[] op1, <#= type.wide #>[] op2, <#= type.wide #>[] op3, int i) => i < op1.Length ? op1[i] : SubtractRoundedHighNarrow(op2[i - op1.Length], op3[i - op1.Length]);
public static <#= type.wide #> SubtractWidening(<#= type.name #> op1, <#= type.name #> op2) => (<#= type.wide #>)((<#= type.wide #>)op1 - (<#= type.wide #>)op2);
public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
/// <summary>
+ /// uint8x8_t vaddhn_u16 (uint16x8_t a, uint16x8_t b)
+ /// A32: VADDHN.I16 Dd, Qn, Qm
+ /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H
+ /// </summary>
+ public static Vector64<byte> AddHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int16x4_t vaddhn_s32 (int32x4_t a, int32x4_t b)
+ /// A32: VADDHN.I32 Dd, Qn, Qm
+ /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S
+ /// </summary>
+ public static Vector64<short> AddHighNarrowLower(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int32x2_t vaddhn_s64 (int64x2_t a, int64x2_t b)
+ /// A32: VADDHN.I64 Dd, Qn, Qm
+ /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D
+ /// </summary>
+ public static Vector64<int> AddHighNarrowLower(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int8x8_t vaddhn_s16 (int16x8_t a, int16x8_t b)
+ /// A32: VADDHN.I16 Dd, Qn, Qm
+ /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H
+ /// </summary>
+ public static Vector64<sbyte> AddHighNarrowLower(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// uint16x4_t vaddhn_u32 (uint32x4_t a, uint32x4_t b)
+ /// A32: VADDHN.I32 Dd, Qn, Qm
+ /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S
+ /// </summary>
+ public static Vector64<ushort> AddHighNarrowLower(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// uint32x2_t vaddhn_u64 (uint64x2_t a, uint64x2_t b)
+ /// A32: VADDHN.I64 Dd, Qn, Qm
+ /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D
+ /// </summary>
+ public static Vector64<uint> AddHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// uint8x16_t vaddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
+ /// A32: VADDHN.I16 Dd+1, Qn, Qm
+ /// A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H
+ /// </summary>
+ public static Vector128<byte> AddHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int16x8_t vaddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
+ /// A32: VADDHN.I32 Dd+1, Qn, Qm
+ /// A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S
+ /// </summary>
+ public static Vector128<short> AddHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int32x4_t vaddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
+ /// A32: VADDHN.I64 Dd+1, Qn, Qm
+ /// A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D
+ /// </summary>
+ public static Vector128<int> AddHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// int8x16_t vaddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
+ /// A32: VADDHN.I16 Dd+1, Qn, Qm
+ /// A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H
+ /// </summary>
+ public static Vector128<sbyte> AddHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// uint16x8_t vaddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
+ /// A32: VADDHN.I32 Dd+1, Qn, Qm
+ /// A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S
+ /// </summary>
+ public static Vector128<ushort> AddHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// uint32x4_t vaddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
+ /// A32: VADDHN.I64 Dd+1, Qn, Qm
+ /// A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D
+ /// </summary>
+ public static Vector128<uint> AddHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
/// uint8x8_t vpadd_u8 (uint8x8_t a, uint8x8_t b)
/// A32: VPADD.I8 Dd, Dn, Dm
/// A64: ADDP Vd.8B, Vn.8B, Vm.8B
public static Vector64<ulong> AddPairwiseWideningScalar(Vector64<uint> value) { throw new PlatformNotSupportedException(); }
/// <summary>
- /// uint8x8_t vaddhn_u16 (uint16x8_t a, uint16x8_t b)
- /// A32: VADDHN.I16 Dd, Qn, Qm
- /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H
- /// </summary>
- public static Vector64<byte> AddReturningHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// int16x4_t vaddhn_s32 (int32x4_t a, int32x4_t b)
- /// A32: VADDHN.I32 Dd, Qn, Qm
- /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S
- /// </summary>
- public static Vector64<short> AddReturningHighNarrowLower(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// int32x2_t vaddhn_s64 (int64x2_t a, int64x2_t b)
- /// A32: VADDHN.I64 Dd, Qn, Qm
- /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D
- /// </summary>
- public static Vector64<int> AddReturningHighNarrowLower(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// int8x8_t vaddhn_s16 (int16x8_t a, int16x8_t b)
- /// A32: VADDHN.I16 Dd, Qn, Qm
- /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H
- /// </summary>
- public static Vector64<sbyte> AddReturningHighNarrowLower(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// uint16x4_t vaddhn_u32 (uint32x4_t a, uint32x4_t b)
- /// A32: VADDHN.I32 Dd, Qn, Qm
- /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S
- /// </summary>
- public static Vector64<ushort> AddReturningHighNarrowLower(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// uint32x2_t vaddhn_u64 (uint64x2_t a, uint64x2_t b)
- /// A32: VADDHN.I64 Dd, Qn, Qm
- /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D
- /// </summary>
- public static Vector64<uint> AddReturningHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// uint8x16_t vaddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
- /// A32: VADDHN.I16 Dd+1, Qn, Qm
- /// A64: ADDHN2 Vd.16B, Vn.8B, Vm.8H
- /// </summary>
- public static Vector128<byte> AddReturningHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// int16x8_t vaddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
- /// A32: VADDHN.I32 Dd+1, Qn, Qm
- /// A64: ADDHN2 Vd.8H, Vn.4H, Vm.4S
- /// </summary>
- public static Vector128<short> AddReturningHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// int32x4_t vaddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
- /// A32: VADDHN.I64 Dd+1, Qn, Qm
- /// A64: ADDHN2 Vd.4S, Vn.2S, Vm.2D
- /// </summary>
- public static Vector128<int> AddReturningHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// int8x16_t vaddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
- /// A32: VADDHN.I16 Dd+1, Qn, Qm
- /// A64: ADDHN2 Vd.16B, Vn.8B, Vm.8H
- /// </summary>
- public static Vector128<sbyte> AddReturningHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// uint16x8_t vaddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
- /// A32: VADDHN.I32 Dd+1, Qn, Qm
- /// A64: ADDHN2 Vd.8H, Vn.4H, Vm.4S
- /// </summary>
- public static Vector128<ushort> AddReturningHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// uint32x4_t vaddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
- /// A32: VADDHN.I64 Dd+1, Qn, Qm
- /// A64: ADDHN2 Vd.4S, Vn.2S, Vm.2D
- /// </summary>
- public static Vector128<uint> AddReturningHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
/// uint8x8_t vraddhn_u16 (uint16x8_t a, uint16x8_t b)
/// A32: VRADDHN.I16 Dd, Qn, Qm
/// A64: RADDHN Vd.8B, Vn.8H, Vm.8H
/// </summary>
- public static Vector64<byte> AddReturningRoundedHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<byte> AddRoundedHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int16x4_t vraddhn_s32 (int32x4_t a, int32x4_t b)
/// A32: VRADDHN.I32 Dd, Qn, Qm
/// A64: RADDHN Vd.4H, Vn.4S, Vm.4S
/// </summary>
- public static Vector64<short> AddReturningRoundedHighNarrowLower(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<short> AddRoundedHighNarrowLower(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int32x2_t vraddhn_s64 (int64x2_t a, int64x2_t b)
/// A32: VRADDHN.I64 Dd, Qn, Qm
/// A64: RADDHN Vd.2S, Vn.2D, Vm.2D
/// </summary>
- public static Vector64<int> AddReturningRoundedHighNarrowLower(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<int> AddRoundedHighNarrowLower(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int8x8_t vraddhn_s16 (int16x8_t a, int16x8_t b)
/// A32: VRADDHN.I16 Dd, Qn, Qm
/// A64: RADDHN Vd.8B, Vn.8H, Vm.8H
/// </summary>
- public static Vector64<sbyte> AddReturningRoundedHighNarrowLower(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<sbyte> AddRoundedHighNarrowLower(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint16x4_t vraddhn_u32 (uint32x4_t a, uint32x4_t b)
/// A32: VRADDHN.I32 Dd, Qn, Qm
/// A64: RADDHN Vd.4H, Vn.4S, Vm.4S
/// </summary>
- public static Vector64<ushort> AddReturningRoundedHighNarrowLower(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<ushort> AddRoundedHighNarrowLower(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint32x2_t vraddhn_u64 (uint64x2_t a, uint64x2_t b)
/// A32: VRADDHN.I64 Dd, Qn, Qm
/// A64: RADDHN Vd.2S, Vn.2D, Vm.2D
/// </summary>
- public static Vector64<uint> AddR
eturningRoundedHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<uint> AddRoundedHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint8x16_t vraddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
/// A32: VRADDHN.I16 Dd+1, Qn, Qm
- /// A64: RADDHN2 Vd.16B, Vn.8B, Vm.8H
+ /// A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H
/// </summary>
- public static Vector128<byte> AddReturningRoundedHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<byte> AddRoundedHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int16x8_t vraddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
/// A32: VRADDHN.I32 Dd+1, Qn, Qm
- /// A64: RADDHN2 Vd.8H, Vn.4H, Vm.4S
+ /// A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S
/// </summary>
- public static Vector128<short> AddReturningRoundedHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<short> AddRoundedHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int32x4_t vraddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
/// A32: VRADDHN.I64 Dd+1, Qn, Qm
- /// A64: RADDHN2 Vd.4S, Vn.2S, Vm.2D
+ /// A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D
/// </summary>
- public static Vector128<int> AddReturningRoundedHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<int> AddRoundedHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int8x16_t vraddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
/// A32: VRADDHN.I16 Dd+1, Qn, Qm
- /// A64: RADDHN2 Vd.16B, Vn.8B, Vm.8H
+ /// A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H
/// </summary>
- public static Vector128<sbyte> AddReturningRoundedHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<sbyte> AddRoundedHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint16x8_t vraddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
/// A32: VRADDHN.I32 Dd+1, Qn, Qm
- /// A64: RADDHN2 Vd.8H, Vn.4H, Vm.4S
+ /// A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S
/// </summary>
- public static Vector128<ushort> AddReturningRoundedHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<ushort> AddRoundedHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint32x4_t vraddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
/// A32: VRADDHN.I64 Dd+1, Qn, Qm
- /// A64: RADDHN2 Vd.4S, Vn.2S, Vm.2D
+ /// A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D
/// </summary>
- public static Vector128<uint> AddR
eturningRoundedHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<uint> AddRoundedHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint8x8_t vqadd_u8 (uint8x8_t a, uint8x8_t b)
/// A32: VSUBHN.I16 Dd, Qn, Qm
/// A64: SUBHN Vd.8B, Vn.8H, Vm.8H
/// </summary>
- public static Vector64<byte> SubtractReturningHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<byte> SubtractHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int16x4_t vsubhn_s32 (int32x4_t a, int32x4_t b)
/// A32: VSUBHN.I32 Dd, Qn, Qm
/// A64: SUBHN Vd.4H, Vn.4S, Vm.4S
/// </summary>
- public static Vector64<short> SubtractReturningHighNarrowLower(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<short> SubtractHighNarrowLower(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int32x2_t vsubhn_s64 (int64x2_t a, int64x2_t b)
/// A32: VSUBHN.I64 Dd, Qn, Qm
/// A64: SUBHN Vd.2S, Vn.2D, Vm.2D
/// </summary>
- public static Vector64<int> SubtractReturningHighNarrowLower(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<int> SubtractHighNarrowLower(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int8x8_t vsubhn_s16 (int16x8_t a, int16x8_t b)
/// A32: VSUBHN.I16 Dd, Qn, Qm
/// A64: SUBHN Vd.8B, Vn.8H, Vm.8H
/// </summary>
- public static Vector64<sbyte> SubtractReturningHighNarrowLower(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<sbyte> SubtractHighNarrowLower(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint16x4_t vsubhn_u32 (uint32x4_t a, uint32x4_t b)
/// A32: VSUBHN.I32 Dd, Qn, Qm
/// A64: SUBHN Vd.4H, Vn.4S, Vm.4S
/// </summary>
- public static Vector64<ushort> SubtractReturningHighNarrowLower(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<ushort> SubtractHighNarrowLower(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint32x2_t vsubhn_u64 (uint64x2_t a, uint64x2_t b)
/// A32: VSUBHN.I64 Dd, Qn, Qm
/// A64: SUBHN Vd.2S, Vn.2D, Vm.2D
/// </summary>
- public static Vector64<uint> Subtract
ReturningHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<uint> SubtractHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint8x16_t vsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
/// A32: VSUBHN.I16 Dd+1, Qn, Qm
- /// A64: SUBHN2 Vd.16B, Vn.8B, Vm.8H
+ /// A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H
/// </summary>
- public static Vector128<byte> SubtractReturningHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<byte> SubtractHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int16x8_t vsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
/// A32: VSUBHN.I32 Dd+1, Qn, Qm
- /// A64: SUBHN2 Vd.8H, Vn.4H, Vm.4S
+ /// A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S
/// </summary>
- public static Vector128<short> SubtractReturningHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<short> SubtractHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int32x4_t vsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
/// A32: VSUBHN.I64 Dd+1, Qn, Qm
- /// A64: SUBHN2 Vd.4S, Vn.2S, Vm.2D
+ /// A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D
/// </summary>
- public static Vector128<int> SubtractReturningHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<int> SubtractHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int8x16_t vsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
/// A32: VSUBHN.I16 Dd+1, Qn, Qm
- /// A64: SUBHN2 Vd.16B, Vn.8B, Vm.8H
+ /// A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H
/// </summary>
- public static Vector128<sbyte> SubtractReturningHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<sbyte> SubtractHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint16x8_t vsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
/// A32: VSUBHN.I32 Dd+1, Qn, Qm
- /// A64: SUBHN2 Vd.8H, Vn.4H, Vm.4S
+ /// A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S
/// </summary>
- public static Vector128<ushort> SubtractReturningHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<ushort> SubtractHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint32x4_t vsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
/// A32: VSUBHN.I64 Dd+1, Qn, Qm
- /// A64: SUBHN2 Vd.4S, Vn.2S, Vm.2D
+ /// A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D
/// </summary>
- public static Vector128<uint> Subtract
ReturningHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<uint> SubtractHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint8x8_t vrsubhn_u16 (uint16x8_t a, uint16x8_t b)
/// A32: VRSUBHN.I16 Dd, Qn, Qm
/// A64: RSUBHN Vd.8B, Vn.8H, Vm.8H
/// </summary>
- public static Vector64<byte> SubtractReturningRoundedHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<byte> SubtractRoundedHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int16x4_t vrsubhn_s32 (int32x4_t a, int32x4_t b)
/// A32: VRSUBHN.I32 Dd, Qn, Qm
/// A64: RSUBHN Vd.4H, Vn.4S, Vm.4S
/// </summary>
- public static Vector64<short> SubtractReturningRoundedHighNarrowLower(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<short> SubtractRoundedHighNarrowLower(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int32x2_t vrsubhn_s64 (int64x2_t a, int64x2_t b)
/// A32: VRSUBHN.I64 Dd, Qn, Qm
/// A64: RSUBHN Vd.2S, Vn.2D, Vm.2D
/// </summary>
- public static Vector64<int> SubtractReturningRoundedHighNarrowLower(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<int> SubtractRoundedHighNarrowLower(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int8x8_t vrsubhn_s16 (int16x8_t a, int16x8_t b)
/// A32: VRSUBHN.I16 Dd, Qn, Qm
/// A64: RSUBHN Vd.8B, Vn.8H, Vm.8H
/// </summary>
- public static Vector64<sbyte> SubtractReturningRoundedHighNarrowLower(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<sbyte> SubtractRoundedHighNarrowLower(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint16x4_t vrsubhn_u32 (uint32x4_t a, uint32x4_t b)
/// A32: VRSUBHN.I32 Dd, Qn, Qm
/// A64: RSUBHN Vd.4H, Vn.4S, Vm.4S
/// </summary>
- public static Vector64<ushort> SubtractReturningRoundedHighNarrowLower(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<ushort> SubtractRoundedHighNarrowLower(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint32x2_t vrsubhn_u64 (uint64x2_t a, uint64x2_t b)
/// A32: VRSUBHN.I64 Dd, Qn, Qm
/// A64: RSUBHN Vd.2S, Vn.2D, Vm.2D
/// </summary>
- public static Vector64<uint> SubtractR
eturningRoundedHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ public static Vector64<uint> SubtractRoundedHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint8x16_t vrsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
/// A32: VRSUBHN.I16 Dd+1, Qn, Qm
- /// A64: RSUBHN2 Vd.16B, Vn.8B, Vm.8H
+ /// A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H
/// </summary>
- public static Vector128<byte> SubtractReturningRoundedHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<byte> SubtractRoundedHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int16x8_t vrsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
/// A32: VRSUBHN.I32 Dd+1, Qn, Qm
- /// A64: RSUBHN2 Vd.8H, Vn.4H, Vm.4S
+ /// A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S
/// </summary>
- public static Vector128<short> SubtractReturningRoundedHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<short> SubtractRoundedHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int32x4_t vrsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
/// A32: VRSUBHN.I64 Dd+1, Qn, Qm
- /// A64: RSUBHN2 Vd.4S, Vn.2S, Vm.2D
+ /// A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D
/// </summary>
- public static Vector128<int> SubtractReturningRoundedHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<int> SubtractRoundedHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int8x16_t vrsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
/// A32: VRSUBHN.I16 Dd+1, Qn, Qm
- /// A64: RSUBHN2 Vd.16B, Vn.8B, Vm.8H
+ /// A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H
/// </summary>
- public static Vector128<sbyte> SubtractReturningRoundedHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<sbyte> SubtractRoundedHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint16x8_t vrsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
/// A32: VRSUBHN.I32 Dd+1, Qn, Qm
- /// A64: RSUBHN2 Vd.8H, Vn.4H, Vm.4S
+ /// A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S
/// </summary>
- public static Vector128<ushort> SubtractReturningRoundedHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<ushort> SubtractRoundedHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint32x4_t vrsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
/// A32: VRSUBHN.I64 Dd+1, Qn, Qm
- /// A64: RSUBHN2 Vd.4S, Vn.2S, Vm.2D
+ /// A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D
/// </summary>
- public static Vector128<uint> SubtractR
eturningRoundedHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+ public static Vector128<uint> SubtractRoundedHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint8x8_t vqsub_u8 (uint8x8_t a, uint8x8_t b)
public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right) => Add(left, right);
/// <summary>
+ /// uint8x8_t vaddhn_u16 (uint16x8_t a, uint16x8_t b)
+ /// A32: VADDHN.I16 Dd, Qn, Qm
+ /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H
+ /// </summary>
+ public static Vector64<byte> AddHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) => AddHighNarrowLower(left, right);
+
+ /// <summary>
+ /// int16x4_t vaddhn_s32 (int32x4_t a, int32x4_t b)
+ /// A32: VADDHN.I32 Dd, Qn, Qm
+ /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S
+ /// </summary>
+ public static Vector64<short> AddHighNarrowLower(Vector128<int> left, Vector128<int> right) => AddHighNarrowLower(left, right);
+
+ /// <summary>
+ /// int32x2_t vaddhn_s64 (int64x2_t a, int64x2_t b)
+ /// A32: VADDHN.I64 Dd, Qn, Qm
+ /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D
+ /// </summary>
+ public static Vector64<int> AddHighNarrowLower(Vector128<long> left, Vector128<long> right) => AddHighNarrowLower(left, right);
+
+ /// <summary>
+ /// int8x8_t vaddhn_s16 (int16x8_t a, int16x8_t b)
+ /// A32: VADDHN.I16 Dd, Qn, Qm
+ /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H
+ /// </summary>
+ public static Vector64<sbyte> AddHighNarrowLower(Vector128<short> left, Vector128<short> right) => AddHighNarrowLower(left, right);
+
+ /// <summary>
+ /// uint16x4_t vaddhn_u32 (uint32x4_t a, uint32x4_t b)
+ /// A32: VADDHN.I32 Dd, Qn, Qm
+ /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S
+ /// </summary>
+ public static Vector64<ushort> AddHighNarrowLower(Vector128<uint> left, Vector128<uint> right) => AddHighNarrowLower(left, right);
+
+ /// <summary>
+ /// uint32x2_t vaddhn_u64 (uint64x2_t a, uint64x2_t b)
+ /// A32: VADDHN.I64 Dd, Qn, Qm
+ /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D
+ /// </summary>
+ public static Vector64<uint> AddHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) => AddHighNarrowLower(left, right);
+
+ /// <summary>
+ /// uint8x16_t vaddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
+ /// A32: VADDHN.I16 Dd+1, Qn, Qm
+ /// A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H
+ /// </summary>
+ public static Vector128<byte> AddHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) => AddHighNarrowUpper(lower, left, right);
+
+ /// <summary>
+ /// int16x8_t vaddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
+ /// A32: VADDHN.I32 Dd+1, Qn, Qm
+ /// A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S
+ /// </summary>
+ public static Vector128<short> AddHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) => AddHighNarrowUpper(lower, left, right);
+
+ /// <summary>
+ /// int32x4_t vaddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
+ /// A32: VADDHN.I64 Dd+1, Qn, Qm
+ /// A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D
+ /// </summary>
+ public static Vector128<int> AddHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) => AddHighNarrowUpper(lower, left, right);
+
+ /// <summary>
+ /// int8x16_t vaddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
+ /// A32: VADDHN.I16 Dd+1, Qn, Qm
+ /// A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H
+ /// </summary>
+ public static Vector128<sbyte> AddHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) => AddHighNarrowUpper(lower, left, right);
+
+ /// <summary>
+ /// uint16x8_t vaddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
+ /// A32: VADDHN.I32 Dd+1, Qn, Qm
+ /// A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S
+ /// </summary>
+ public static Vector128<ushort> AddHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) => AddHighNarrowUpper(lower, left, right);
+
+ /// <summary>
+ /// uint32x4_t vaddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
+ /// A32: VADDHN.I64 Dd+1, Qn, Qm
+ /// A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D
+ /// </summary>
+ public static Vector128<uint> AddHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) => AddHighNarrowUpper(lower, left, right);
+
+ /// <summary>
/// uint8x8_t vpadd_u8 (uint8x8_t a, uint8x8_t b)
/// A32: VPADD.I8 Dd, Dn, Dm
/// A64: ADDP Vd.8B, Vn.8B, Vm.8B
public static Vector64<ulong> AddPairwiseWideningScalar(Vector64<uint> value) => AddPairwiseWideningScalar(value);
/// <summary>
- /// uint8x8_t vaddhn_u16 (uint16x8_t a, uint16x8_t b)
- /// A32: VADDHN.I16 Dd, Qn, Qm
- /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H
- /// </summary>
- public static Vector64<byte> AddReturningHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) => AddReturningHighNarrowLower(left, right);
-
- /// <summary>
- /// int16x4_t vaddhn_s32 (int32x4_t a, int32x4_t b)
- /// A32: VADDHN.I32 Dd, Qn, Qm
- /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S
- /// </summary>
- public static Vector64<short> AddReturningHighNarrowLower(Vector128<int> left, Vector128<int> right) => AddReturningHighNarrowLower(left, right);
-
- /// <summary>
- /// int32x2_t vaddhn_s64 (int64x2_t a, int64x2_t b)
- /// A32: VADDHN.I64 Dd, Qn, Qm
- /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D
- /// </summary>
- public static Vector64<int> AddReturningHighNarrowLower(Vector128<long> left, Vector128<long> right) => AddReturningHighNarrowLower(left, right);
-
- /// <summary>
- /// int8x8_t vaddhn_s16 (int16x8_t a, int16x8_t b)
- /// A32: VADDHN.I16 Dd, Qn, Qm
- /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H
- /// </summary>
- public static Vector64<sbyte> AddReturningHighNarrowLower(Vector128<short> left, Vector128<short> right) => AddReturningHighNarrowLower(left, right);
-
- /// <summary>
- /// uint16x4_t vaddhn_u32 (uint32x4_t a, uint32x4_t b)
- /// A32: VADDHN.I32 Dd, Qn, Qm
- /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S
- /// </summary>
- public static Vector64<ushort> AddReturningHighNarrowLower(Vector128<uint> left, Vector128<uint> right) => AddReturningHighNarrowLower(left, right);
-
- /// <summary>
- /// uint32x2_t vaddhn_u64 (uint64x2_t a, uint64x2_t b)
- /// A32: VADDHN.I64 Dd, Qn, Qm
- /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D
- /// </summary>
- public static Vector64<uint> AddReturningHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) => AddReturningHighNarrowLower(left, right);
-
- /// <summary>
- /// uint8x16_t vaddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
- /// A32: VADDHN.I16 Dd+1, Qn, Qm
- /// A64: ADDHN2 Vd.16B, Vn.8B, Vm.8H
- /// </summary>
- public static Vector128<byte> AddReturningHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) => AddReturningHighNarrowUpper(lower, left, right);
-
- /// <summary>
- /// int16x8_t vaddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
- /// A32: VADDHN.I32 Dd+1, Qn, Qm
- /// A64: ADDHN2 Vd.8H, Vn.4H, Vm.4S
- /// </summary>
- public static Vector128<short> AddReturningHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) => AddReturningHighNarrowUpper(lower, left, right);
-
- /// <summary>
- /// int32x4_t vaddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
- /// A32: VADDHN.I64 Dd+1, Qn, Qm
- /// A64: ADDHN2 Vd.4S, Vn.2S, Vm.2D
- /// </summary>
- public static Vector128<int> AddReturningHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) => AddReturningHighNarrowUpper(lower, left, right);
-
- /// <summary>
- /// int8x16_t vaddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
- /// A32: VADDHN.I16 Dd+1, Qn, Qm
- /// A64: ADDHN2 Vd.16B, Vn.8B, Vm.8H
- /// </summary>
- public static Vector128<sbyte> AddReturningHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) => AddReturningHighNarrowUpper(lower, left, right);
-
- /// <summary>
- /// uint16x8_t vaddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
- /// A32: VADDHN.I32 Dd+1, Qn, Qm
- /// A64: ADDHN2 Vd.8H, Vn.4H, Vm.4S
- /// </summary>
- public static Vector128<ushort> AddReturningHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) => AddReturningHighNarrowUpper(lower, left, right);
-
- /// <summary>
- /// uint32x4_t vaddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
- /// A32: VADDHN.I64 Dd+1, Qn, Qm
- /// A64: ADDHN2 Vd.4S, Vn.2S, Vm.2D
- /// </summary>
- public static Vector128<uint> AddReturningHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) => AddReturningHighNarrowUpper(lower, left, right);
-
- /// <summary>
/// uint8x8_t vraddhn_u16 (uint16x8_t a, uint16x8_t b)
/// A32: VRADDHN.I16 Dd, Qn, Qm
/// A64: RADDHN Vd.8B, Vn.8H, Vm.8H
/// </summary>
- public static Vector64<byte> AddReturningRoundedHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) => AddReturningRoundedHighNarrowLower(left, right);
+ public static Vector64<byte> AddRoundedHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) => AddRoundedHighNarrowLower(left, right);
/// <summary>
/// int16x4_t vraddhn_s32 (int32x4_t a, int32x4_t b)
/// A32: VRADDHN.I32 Dd, Qn, Qm
/// A64: RADDHN Vd.4H, Vn.4S, Vm.4S
/// </summary>
- public static Vector64<short> AddReturningRoundedHighNarrowLower(Vector128<int> left, Vector128<int> right) => AddReturningRoundedHighNarrowLower(left, right);
+ public static Vector64<short> AddRoundedHighNarrowLower(Vector128<int> left, Vector128<int> right) => AddRoundedHighNarrowLower(left, right);
/// <summary>
/// int32x2_t vraddhn_s64 (int64x2_t a, int64x2_t b)
/// A32: VRADDHN.I64 Dd, Qn, Qm
/// A64: RADDHN Vd.2S, Vn.2D, Vm.2D
/// </summary>
- public static Vector64<int> AddReturningRoundedHighNarrowLower(Vector128<long> left, Vector128<long> right) => AddReturningRoundedHighNarrowLower(left, right);
+ public static Vector64<int> AddRoundedHighNarrowLower(Vector128<long> left, Vector128<long> right) => AddRoundedHighNarrowLower(left, right);
/// <summary>
/// int8x8_t vraddhn_s16 (int16x8_t a, int16x8_t b)
/// A32: VRADDHN.I16 Dd, Qn, Qm
/// A64: RADDHN Vd.8B, Vn.8H, Vm.8H
/// </summary>
- public static Vector64<sbyte> AddReturningRoundedHighNarrowLower(Vector128<short> left, Vector128<short> right) => AddReturningRoundedHighNarrowLower(left, right);
+ public static Vector64<sbyte> AddRoundedHighNarrowLower(Vector128<short> left, Vector128<short> right) => AddRoundedHighNarrowLower(left, right);
/// <summary>
/// uint16x4_t vraddhn_u32 (uint32x4_t a, uint32x4_t b)
/// A32: VRADDHN.I32 Dd, Qn, Qm
/// A64: RADDHN Vd.4H, Vn.4S, Vm.4S
/// </summary>
- public static Vector64<ushort> AddReturningRoundedHighNarrowLower(Vector128<uint> left, Vector128<uint> right) => AddReturningRoundedHighNarrowLower(left, right);
+ public static Vector64<ushort> AddRoundedHighNarrowLower(Vector128<uint> left, Vector128<uint> right) => AddRoundedHighNarrowLower(left, right);
/// <summary>
/// uint32x2_t vraddhn_u64 (uint64x2_t a, uint64x2_t b)
/// A32: VRADDHN.I64 Dd, Qn, Qm
/// A64: RADDHN Vd.2S, Vn.2D, Vm.2D
/// </summary>
- public static Vector64<uint> AddReturningRoundedHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) => AddReturningRoundedHighNarrowLower(left, right);
+ public static Vector64<uint> AddRoundedHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) => AddRoundedHighNarrowLower(left, right);
/// <summary>
/// uint8x16_t vraddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
/// A32: VRADDHN.I16 Dd+1, Qn, Qm
- /// A64: RADDHN2 Vd.16B, Vn.8B, Vm.8H
+ /// A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H
/// </summary>
- public static Vector128<byte> AddReturningRoundedHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) => AddReturningRoundedHighNarrowUpper(lower, left, right);
+ public static Vector128<byte> AddRoundedHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) => AddRoundedHighNarrowUpper(lower, left, right);
/// <summary>
/// int16x8_t vraddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
/// A32: VRADDHN.I32 Dd+1, Qn, Qm
- /// A64: RADDHN2 Vd.8H, Vn.4H, Vm.4S
+ /// A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S
/// </summary>
- public static Vector128<short> AddReturningRoundedHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) => AddReturningRoundedHighNarrowUpper(lower, left, right);
+ public static Vector128<short> AddRoundedHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) => AddRoundedHighNarrowUpper(lower, left, right);
/// <summary>
/// int32x4_t vraddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
/// A32: VRADDHN.I64 Dd+1, Qn, Qm
- /// A64: RADDHN2 Vd.4S, Vn.2S, Vm.2D
+ /// A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D
/// </summary>
- public static Vector128<int> AddReturningRoundedHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) => AddReturningRoundedHighNarrowUpper(lower, left, right);
+ public static Vector128<int> AddRoundedHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) => AddRoundedHighNarrowUpper(lower, left, right);
/// <summary>
/// int8x16_t vraddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
/// A32: VRADDHN.I16 Dd+1, Qn, Qm
- /// A64: RADDHN2 Vd.16B, Vn.8B, Vm.8H
+ /// A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H
/// </summary>
- public static Vector128<sbyte> AddReturningRoundedHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) => AddReturningRoundedHighNarrowUpper(lower, left, right);
+ public static Vector128<sbyte> AddRoundedHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) => AddRoundedHighNarrowUpper(lower, left, right);
/// <summary>
/// uint16x8_t vraddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
/// A32: VRADDHN.I32 Dd+1, Qn, Qm
- /// A64: RADDHN2 Vd.8H, Vn.4H, Vm.4S
+ /// A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S
/// </summary>
- public static Vector128<ushort> AddReturningRoundedHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) => AddReturningRoundedHighNarrowUpper(lower, left, right);
+ public static Vector128<ushort> AddRoundedHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) => AddRoundedHighNarrowUpper(lower, left, right);
/// <summary>
/// uint32x4_t vraddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
/// A32: VRADDHN.I64 Dd+1, Qn, Qm
- /// A64: RADDHN2 Vd.4S, Vn.2S, Vm.2D
+ /// A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D
/// </summary>
- public static Vector128<uint> AddReturningRoundedHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) => AddReturningRoundedHighNarrowUpper(lower, left, right);
+ public static Vector128<uint> AddRoundedHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) => AddRoundedHighNarrowUpper(lower, left, right);
/// <summary>
/// uint8x8_t vqadd_u8 (uint8x8_t a, uint8x8_t b)
/// A32: VSUBHN.I16 Dd, Qn, Qm
/// A64: SUBHN Vd.8B, Vn.8H, Vm.8H
/// </summary>
- public static Vector64<byte> SubtractReturningHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) => SubtractReturningHighNarrowLower(left, right);
+ public static Vector64<byte> SubtractHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) => SubtractHighNarrowLower(left, right);
/// <summary>
/// int16x4_t vsubhn_s32 (int32x4_t a, int32x4_t b)
/// A32: VSUBHN.I32 Dd, Qn, Qm
/// A64: SUBHN Vd.4H, Vn.4S, Vm.4S
/// </summary>
- public static Vector64<short> SubtractReturningHighNarrowLower(Vector128<int> left, Vector128<int> right) => SubtractReturningHighNarrowLower(left, right);
+ public static Vector64<short> SubtractHighNarrowLower(Vector128<int> left, Vector128<int> right) => SubtractHighNarrowLower(left, right);
/// <summary>
/// int32x2_t vsubhn_s64 (int64x2_t a, int64x2_t b)
/// A32: VSUBHN.I64 Dd, Qn, Qm
/// A64: SUBHN Vd.2S, Vn.2D, Vm.2D
/// </summary>
- public static Vector64<int> SubtractReturningHighNarrowLower(Vector128<long> left, Vector128<long> right) => SubtractReturningHighNarrowLower(left, right);
+ public static Vector64<int> SubtractHighNarrowLower(Vector128<long> left, Vector128<long> right) => SubtractHighNarrowLower(left, right);
/// <summary>
/// int8x8_t vsubhn_s16 (int16x8_t a, int16x8_t b)
/// A32: VSUBHN.I16 Dd, Qn, Qm
/// A64: SUBHN Vd.8B, Vn.8H, Vm.8H
/// </summary>
- public static Vector64<sbyte> SubtractReturningHighNarrowLower(Vector128<short> left, Vector128<short> right) => SubtractReturningHighNarrowLower(left, right);
+ public static Vector64<sbyte> SubtractHighNarrowLower(Vector128<short> left, Vector128<short> right) => SubtractHighNarrowLower(left, right);
/// <summary>
/// uint16x4_t vsubhn_u32 (uint32x4_t a, uint32x4_t b)
/// A32: VSUBHN.I32 Dd, Qn, Qm
/// A64: SUBHN Vd.4H, Vn.4S, Vm.4S
/// </summary>
- public static Vector64<ushort> SubtractReturningHighNarrowLower(Vector128<uint> left, Vector128<uint> right) => SubtractReturningHighNarrowLower(left, right);
+ public static Vector64<ushort> SubtractHighNarrowLower(Vector128<uint> left, Vector128<uint> right) => SubtractHighNarrowLower(left, right);
/// <summary>
/// uint32x2_t vsubhn_u64 (uint64x2_t a, uint64x2_t b)
/// A32: VSUBHN.I64 Dd, Qn, Qm
/// A64: SUBHN Vd.2S, Vn.2D, Vm.2D
/// </summary>
- public static Vector64<uint> SubtractReturningHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) => SubtractReturningHighNarrowLower(left, right);
+ public static Vector64<uint> SubtractHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) => SubtractHighNarrowLower(left, right);
/// <summary>
/// uint8x16_t vsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
/// A32: VSUBHN.I16 Dd+1, Qn, Qm
- /// A64: SUBHN2 Vd.16B, Vn.8B, Vm.8H
+ /// A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H
/// </summary>
- public static Vector128<byte> SubtractReturningHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) => SubtractReturningHighNarrowUpper(lower, left, right);
+ public static Vector128<byte> SubtractHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) => SubtractHighNarrowUpper(lower, left, right);
/// <summary>
/// int16x8_t vsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
/// A32: VSUBHN.I32 Dd+1, Qn, Qm
- /// A64: SUBHN2 Vd.8H, Vn.4H, Vm.4S
+ /// A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S
/// </summary>
- public static Vector128<short> SubtractReturningHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) => SubtractReturningHighNarrowUpper(lower, left, right);
+ public static Vector128<short> SubtractHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) => SubtractHighNarrowUpper(lower, left, right);
/// <summary>
/// int32x4_t vsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
/// A32: VSUBHN.I64 Dd+1, Qn, Qm
- /// A64: SUBHN2 Vd.4S, Vn.2S, Vm.2D
+ /// A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D
/// </summary>
- public static Vector128<int> SubtractReturningHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) => SubtractReturningHighNarrowUpper(lower, left, right);
+ public static Vector128<int> SubtractHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) => SubtractHighNarrowUpper(lower, left, right);
/// <summary>
/// int8x16_t vsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
/// A32: VSUBHN.I16 Dd+1, Qn, Qm
- /// A64: SUBHN2 Vd.16B, Vn.8B, Vm.8H
+ /// A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H
/// </summary>
- public static Vector128<sbyte> SubtractReturningHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) => SubtractReturningHighNarrowUpper(lower, left, right);
+ public static Vector128<sbyte> SubtractHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) => SubtractHighNarrowUpper(lower, left, right);
/// <summary>
/// uint16x8_t vsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
/// A32: VSUBHN.I32 Dd+1, Qn, Qm
- /// A64: SUBHN2 Vd.8H, Vn.4H, Vm.4S
+ /// A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S
/// </summary>
- public static Vector128<ushort> SubtractReturningHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) => SubtractReturningHighNarrowUpper(lower, left, right);
+ public static Vector128<ushort> SubtractHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) => SubtractHighNarrowUpper(lower, left, right);
/// <summary>
/// uint32x4_t vsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
/// A32: VSUBHN.I64 Dd+1, Qn, Qm
- /// A64: SUBHN2 Vd.4S, Vn.2S, Vm.2D
+ /// A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D
/// </summary>
- public static Vector128<uint> SubtractReturningHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) => SubtractReturningHighNarrowUpper(lower, left, right);
+ public static Vector128<uint> SubtractHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) => SubtractHighNarrowUpper(lower, left, right);
/// <summary>
/// uint8x8_t vrsubhn_u16 (uint16x8_t a, uint16x8_t b)
/// A32: VRSUBHN.I16 Dd, Qn, Qm
/// A64: RSUBHN Vd.8B, Vn.8H, Vm.8H
/// </summary>
- public static Vector64<byte> SubtractReturningRoundedHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) => SubtractReturningRoundedHighNarrowLower(left, right);
+ public static Vector64<byte> SubtractRoundedHighNarrowLower(Vector128<ushort> left, Vector128<ushort> right) => SubtractRoundedHighNarrowLower(left, right);
/// <summary>
/// int16x4_t vrsubhn_s32 (int32x4_t a, int32x4_t b)
/// A32: VRSUBHN.I32 Dd, Qn, Qm
/// A64: RSUBHN Vd.4H, Vn.4S, Vm.4S
/// </summary>
- public static Vector64<short> SubtractReturningRoundedHighNarrowLower(Vector128<int> left, Vector128<int> right) => SubtractReturningRoundedHighNarrowLower(left, right);
+ public static Vector64<short> SubtractRoundedHighNarrowLower(Vector128<int> left, Vector128<int> right) => SubtractRoundedHighNarrowLower(left, right);
/// <summary>
/// int32x2_t vrsubhn_s64 (int64x2_t a, int64x2_t b)
/// A32: VRSUBHN.I64 Dd, Qn, Qm
/// A64: RSUBHN Vd.2S, Vn.2D, Vm.2D
/// </summary>
- public static Vector64<int> SubtractReturningRoundedHighNarrowLower(Vector128<long> left, Vector128<long> right) => SubtractReturningRoundedHighNarrowLower(left, right);
+ public static Vector64<int> SubtractRoundedHighNarrowLower(Vector128<long> left, Vector128<long> right) => SubtractRoundedHighNarrowLower(left, right);
/// <summary>
/// int8x8_t vrsubhn_s16 (int16x8_t a, int16x8_t b)
/// A32: VRSUBHN.I16 Dd, Qn, Qm
/// A64: RSUBHN Vd.8B, Vn.8H, Vm.8H
/// </summary>
- public static Vector64<sbyte> SubtractReturningRoundedHighNarrowLower(Vector128<short> left, Vector128<short> right) => SubtractReturningRoundedHighNarrowLower(left, right);
+ public static Vector64<sbyte> SubtractRoundedHighNarrowLower(Vector128<short> left, Vector128<short> right) => SubtractRoundedHighNarrowLower(left, right);
/// <summary>
/// uint16x4_t vrsubhn_u32 (uint32x4_t a, uint32x4_t b)
/// A32: VRSUBHN.I32 Dd, Qn, Qm
/// A64: RSUBHN Vd.4H, Vn.4S, Vm.4S
/// </summary>
- public static Vector64<ushort> SubtractReturningRoundedHighNarrowLower(Vector128<uint> left, Vector128<uint> right) => SubtractReturningRoundedHighNarrowLower(left, right);
+ public static Vector64<ushort> SubtractRoundedHighNarrowLower(Vector128<uint> left, Vector128<uint> right) => SubtractRoundedHighNarrowLower(left, right);
/// <summary>
/// uint32x2_t vrsubhn_u64 (uint64x2_t a, uint64x2_t b)
/// A32: VRSUBHN.I64 Dd, Qn, Qm
/// A64: RSUBHN Vd.2S, Vn.2D, Vm.2D
/// </summary>
- public static Vector64<uint> SubtractReturningRoundedHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) => SubtractReturningRoundedHighNarrowLower(left, right);
+ public static Vector64<uint> SubtractRoundedHighNarrowLower(Vector128<ulong> left, Vector128<ulong> right) => SubtractRoundedHighNarrowLower(left, right);
/// <summary>
/// uint8x16_t vrsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
/// A32: VRSUBHN.I16 Dd+1, Qn, Qm
- /// A64: RSUBHN2 Vd.16B, Vn.8B, Vm.8H
+ /// A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H
/// </summary>
- public static Vector128<byte> SubtractReturningRoundedHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) => SubtractReturningRoundedHighNarrowUpper(lower, left, right);
+ public static Vector128<byte> SubtractRoundedHighNarrowUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right) => SubtractRoundedHighNarrowUpper(lower, left, right);
/// <summary>
/// int16x8_t vrsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
/// A32: VRSUBHN.I32 Dd+1, Qn, Qm
- /// A64: RSUBHN2 Vd.8H, Vn.4H, Vm.4S
+ /// A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S
/// </summary>
- public static Vector128<short> SubtractReturningRoundedHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) => SubtractReturningRoundedHighNarrowUpper(lower, left, right);
+ public static Vector128<short> SubtractRoundedHighNarrowUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right) => SubtractRoundedHighNarrowUpper(lower, left, right);
/// <summary>
/// int32x4_t vrsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
/// A32: VRSUBHN.I64 Dd+1, Qn, Qm
- /// A64: RSUBHN2 Vd.4S, Vn.2S, Vm.2D
+ /// A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D
/// </summary>
- public static Vector128<int> SubtractReturningRoundedHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) => SubtractReturningRoundedHighNarrowUpper(lower, left, right);
+ public static Vector128<int> SubtractRoundedHighNarrowUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right) => SubtractRoundedHighNarrowUpper(lower, left, right);
/// <summary>
/// int8x16_t vrsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
/// A32: VRSUBHN.I16 Dd+1, Qn, Qm
- /// A64: RSUBHN2 Vd.16B, Vn.8B, Vm.8H
+ /// A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H
/// </summary>
- public static Vector128<sbyte> SubtractReturningRoundedHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) => SubtractReturningRoundedHighNarrowUpper(lower, left, right);
+ public static Vector128<sbyte> SubtractRoundedHighNarrowUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right) => SubtractRoundedHighNarrowUpper(lower, left, right);
/// <summary>
/// uint16x8_t vrsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
/// A32: VRSUBHN.I32 Dd+1, Qn, Qm
- /// A64: RSUBHN2 Vd.8H, Vn.4H, Vm.4S
+ /// A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S
/// </summary>
- public static Vector128<ushort> SubtractReturningRoundedHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) => SubtractReturningRoundedHighNarrowUpper(lower, left, right);
+ public static Vector128<ushort> SubtractRoundedHighNarrowUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right) => SubtractRoundedHighNarrowUpper(lower, left, right);
/// <summary>
/// uint32x4_t vrsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
/// A32: VRSUBHN.I64 Dd+1, Qn, Qm
- /// A64: RSUBHN2 Vd.4S, Vn.2S, Vm.2D
+ /// A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D
/// </summary>
- public static Vector128<uint> SubtractReturningRoundedHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) => SubtractReturningRoundedHighNarrowUpper(lower, left, right);
+ public static Vector128<uint> SubtractRoundedHighNarrowUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right) => SubtractRoundedHighNarrowUpper(lower, left, right);
/// <summary>
/// uint8x8_t vqsub_u8 (uint8x8_t a, uint8x8_t b)
public static System.Runtime.Intrinsics.Vector64<float> Add(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
public static System.Runtime.Intrinsics.Vector64<ushort> Add(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
public static System.Runtime.Intrinsics.Vector64<uint> Add(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<sbyte> AddHighNarrowLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<short> AddHighNarrowLower(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<int> AddHighNarrowLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<byte> AddHighNarrowLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<ushort> AddHighNarrowLower(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<uint> AddHighNarrowLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<byte> AddHighNarrowUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<short> AddHighNarrowUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<int> AddHighNarrowUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<sbyte> AddHighNarrowUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<ushort> AddHighNarrowUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<uint> AddHighNarrowUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
public static System.Runtime.Intrinsics.Vector64<byte> AddPairwise(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
public static System.Runtime.Intrinsics.Vector64<short> AddPairwise(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
public static System.Runtime.Intrinsics.Vector64<int> AddPairwise(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
public static System.Runtime.Intrinsics.Vector64<ulong> AddPairwiseWideningAndAddScalar(System.Runtime.Intrinsics.Vector64<ulong> addend, System.Runtime.Intrinsics.Vector64<uint> value) { throw null; }
public static System.Runtime.Intrinsics.Vector64<long> AddPairwiseWideningScalar(System.Runtime.Intrinsics.Vector64<int> value) { throw null; }
public static System.Runtime.Intrinsics.Vector64<ulong> AddPairwiseWideningScalar(System.Runtime.Intrinsics.Vector64<uint> value) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<sbyte> AddReturningHighNarrowLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<short> AddReturningHighNarrowLower(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<int> AddReturningHighNarrowLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<byte> AddReturningHighNarrowLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<ushort> AddReturningHighNarrowLower(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<uint> AddReturningHighNarrowLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<byte> AddReturningHighNarrowUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<short> AddReturningHighNarrowUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<int> AddReturningHighNarrowUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<sbyte> AddReturningHighNarrowUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<ushort> AddReturningHighNarrowUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<uint> AddReturningHighNarrowUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<sbyte> AddReturningRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<short> AddReturningRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<int> AddReturningRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<byte> AddReturningRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<ushort> AddReturningRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<uint> AddReturningRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<byte> AddReturningRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<short> AddReturningRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<int> AddReturningRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<sbyte> AddReturningRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<ushort> AddReturningRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<uint> AddReturningRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<sbyte> AddRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<short> AddRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<int> AddRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<byte> AddRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<ushort> AddRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<uint> AddRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<byte> AddRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<short> AddRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<int> AddRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<sbyte> AddRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<ushort> AddRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<uint> AddRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
public static System.Runtime.Intrinsics.Vector128<byte> AddSaturate(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
public static System.Runtime.Intrinsics.Vector128<short> AddSaturate(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
public static System.Runtime.Intrinsics.Vector128<int> AddSaturate(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
public static System.Runtime.Intrinsics.Vector64<float> Subtract(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
public static System.Runtime.Intrinsics.Vector64<ushort> Subtract(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
public static System.Runtime.Intrinsics.Vector64<uint> Subtract(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<sbyte> SubtractReturningHighNarrowLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<short> SubtractReturningHighNarrowLower(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<int> SubtractReturningHighNarrowLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<byte> SubtractReturningHighNarrowLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<ushort> SubtractReturningHighNarrowLower(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<uint> Subtract
ReturningHighNarrowLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<byte> SubtractReturningHighNarrowUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<short> SubtractReturningHighNarrowUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<int> SubtractReturningHighNarrowUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<sbyte> SubtractReturningHighNarrowUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<ushort> SubtractReturningHighNarrowUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<uint> Subtract
ReturningHighNarrowUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<sbyte> SubtractReturningRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<short> SubtractReturningRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<int> SubtractReturningRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<byte> SubtractReturningRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<ushort> SubtractReturningRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<uint> SubtractR
eturningRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<byte> SubtractReturningRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<short> SubtractReturningRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<int> SubtractReturningRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<sbyte> SubtractReturningRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<ushort> SubtractReturningRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<uint> SubtractR
eturningRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<sbyte> SubtractHighNarrowLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<short> SubtractHighNarrowLower(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<int> SubtractHighNarrowLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<byte> SubtractHighNarrowLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<ushort> SubtractHighNarrowLower(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<uint> SubtractHighNarrowLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<byte> SubtractHighNarrowUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<short> SubtractHighNarrowUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<int> SubtractHighNarrowUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<sbyte> SubtractHighNarrowUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<ushort> SubtractHighNarrowUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<uint> SubtractHighNarrowUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<sbyte> SubtractRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<short> SubtractRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<int> SubtractRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<byte> SubtractRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<ushort> SubtractRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<uint> SubtractRoundedHighNarrowLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<byte> SubtractRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<short> SubtractRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<int> SubtractRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<sbyte> SubtractRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<ushort> SubtractRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<uint> SubtractRoundedHighNarrowUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
public static System.Runtime.Intrinsics.Vector128<byte> SubtractSaturate(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
public static System.Runtime.Intrinsics.Vector128<short> SubtractSaturate(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
public static System.Runtime.Intrinsics.Vector128<int> SubtractSaturate(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
projects / platform / upstream / dotnet / runtime.git / commitdiff