internal static unsafe int Main(string[] args)
{
int testResult = Pass;
int testsCount = 21;
string methodUnderTestName = nameof(Sse2.Multiply);
if (Sse2.IsSupported)
{
using (var doubleTable = TestTableSse2 <double> .Create(testsCount))
using (var uintTable = TestTableSse2 <uint, ulong> .Create(testsCount, 2.0))
{
for (int i = 0; i < testsCount; i++)
{
(Vector128 <double>, Vector128 <double>, Vector128 <double>)value = doubleTable[i];
Vector128 <double> result = Sse2.Multiply(value.Item1, value.Item2);
doubleTable.SetOutArray(result);
}
for (int i = 0; i < testsCount; i++)
{
(Vector128 <uint>, Vector128 <uint>)value = uintTable[i];
Vector128 <ulong> result = Sse2.Multiply(value.Item1, value.Item2);
uintTable.SetOutArrayU(result);
}
CheckMethod <double> checkDouble = (double x, double y, double z, ref double a) => (a = x * y) == z;
if (!doubleTable.CheckResult(checkDouble))
{
PrintError(doubleTable, methodUnderTestName, "(double x, double y, double z, ref double a) => (a = x * y) == z", checkDouble);
testResult = Fail;
}
CheckMethodFive <uint, ulong> checkUInt32 = (uint x1, uint x2, uint y1, uint y2, ulong z1, ulong z2, ref ulong a1, ref ulong a2) =>
{
a1 = (ulong)x1 * y1;
a2 = (ulong)x2 * y2;
return(a1 == z1 && a2 == z2);
};
if (!uintTable.CheckMultiplyUInt32ToUInt64(checkUInt32))
{
PrintError(uintTable, methodUnderTestName, "(uint x1, uint x2, uint y1, uint y2, ulong z1, ulong z2, ref ulong a1, ref ulong a2) => (a1 = (ulong)x1 * y1) == z1 && (a2 = (ulong)x2 * y2) == z2", checkUInt32);
testResult = Fail;
}
}
}
else
{
Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}");
}
return(testResult);
}
static unsafe int Main(string[] args)
{
int testResult = Pass;
int testsCount = 21;
string methodUnderTestName = nameof(Sse2.UnpackHigh);
if (Sse2.IsSupported)
{
using (var doubleTable = TestTableSse2 <double, double> .Create(testsCount, 1.0))
using (var longTable = TestTableSse2 <long, long> .Create(testsCount, 1.0))
using (var ulongTable = TestTableSse2 <ulong, ulong> .Create(testsCount, 1.0))
using (var intTable = TestTableSse2 <int, int> .Create(testsCount, 1.0))
using (var uintTable = TestTableSse2 <uint, uint> .Create(testsCount, 1.0))
using (var shortTable = TestTableSse2 <short, short> .Create(testsCount, 1.0))
using (var ushortTable = TestTableSse2 <ushort, ushort> .Create(testsCount, 1.0))
using (var sbyteTable = TestTableSse2 <sbyte, sbyte> .Create(testsCount, 1.0))
using (var byteTable = TestTableSse2 <byte, byte> .Create(testsCount, 1.0))
{
for (int i = 0; i < testsCount; i++)
{
(Vector128 <double>, Vector128 <double>)value = doubleTable[i];
Vector128 <double> result = Sse2.UnpackHigh(value.Item1, value.Item2);
doubleTable.SetOutArray(result, i);
}
for (int i = 0; i < testsCount; i++)
{
(Vector128 <long>, Vector128 <long>)value = longTable[i];
Vector128 <long> result = Sse2.UnpackHigh(value.Item1, value.Item2);
longTable.SetOutArray(result, i);
}
for (int i = 0; i < testsCount; i++)
{
(Vector128 <ulong>, Vector128 <ulong>)value = ulongTable[i];
Vector128 <ulong> result = Sse2.UnpackHigh(value.Item1, value.Item2);
ulongTable.SetOutArray(result, i);
}
for (int i = 0; i < testsCount; i++)
{
(Vector128 <int>, Vector128 <int>)value = intTable[i];
Vector128 <int> result = Sse2.UnpackHigh(value.Item1, value.Item2);
intTable.SetOutArray(result, i);
}
for (int i = 0; i < testsCount; i++)
{
(Vector128 <uint>, Vector128 <uint>)value = uintTable[i];
Vector128 <uint> result = Sse2.UnpackHigh(value.Item1, value.Item2);
uintTable.SetOutArray(result, i);
}
for (int i = 0; i < testsCount; i++)
{
(Vector128 <short>, Vector128 <short>)value = shortTable[i];
Vector128 <short> result = Sse2.UnpackHigh(value.Item1, value.Item2);
shortTable.SetOutArray(result);
}
for (int i = 0; i < testsCount; i++)
{
(Vector128 <ushort>, Vector128 <ushort>)value = ushortTable[i];
Vector128 <ushort> result = Sse2.UnpackHigh(value.Item1, value.Item2);
ushortTable.SetOutArray(result);
}
for (int i = 0; i < testsCount; i++)
{
(Vector128 <sbyte>, Vector128 <sbyte>)value = sbyteTable[i];
Vector128 <sbyte> result = Sse2.UnpackHigh(value.Item1, value.Item2);
sbyteTable.SetOutArray(result, i);
}
for (int i = 0; i < testsCount; i++)
{
(Vector128 <byte>, Vector128 <byte>)value = byteTable[i];
Vector128 <byte> result = Sse2.UnpackHigh(value.Item1, value.Item2);
byteTable.SetOutArray(result, i);
}
CheckMethodFive <double, double> checkDouble = (double x1, double x2, double y1, double y2, double z1, double z2, ref double a1, ref double a2) =>
{
return((a1 = x2) == z1 && (a2 = y2) == z2);
};
if (!doubleTable.CheckUnpackHiDouble(checkDouble))
{
PrintError(doubleTable, methodUnderTestName, "(double x, double y, double z, ref double a) => (a = BitwiseXor(x, y)) == z", checkDouble);
testResult = Fail;
}
CheckMethodFive <long, long> checkLong = (long x1, long x2, long y1, long y2, long z1, long z2, ref long a1, ref long a2) =>
{
return((a1 = x2) == z1 && (a2 = y2) == z2);
};
if (!longTable.CheckUnpackHiDouble(checkLong))
{
PrintError(longTable, methodUnderTestName, "(long x, long y, long z, ref long a) => (a = x ^ y) == z", checkLong);
testResult = Fail;
}
CheckMethodFive <ulong, ulong> checkUlong = (ulong x1, ulong x2, ulong y1, ulong y2, ulong z1, ulong z2, ref ulong a1, ref ulong a2) =>
{
return((a1 = x2) == z1 && (a2 = y2) == z2);
};
if (!longTable.CheckUnpackHiDouble(checkLong))
{
PrintError(ulongTable, methodUnderTestName, "(ulong x1, ulong x2, ulong y1, ulong y2, ulong z1, ulong z2, ref ulong a1, ref ulong a2) => (a1 = x2) == z1 && (a2 = y2) == z2", checkUlong);
testResult = Fail;
}
CheckMethodFourTFourU <int, int> checkInt32 =
(ValueTuple <int, int, int, int> x, ValueTuple <int, int, int, int> y,
ValueTuple <int, int, int, int> z,
ref int a1, ref int a2, ref int a3, ref int a4) =>
{
a1 = x.Item3;
a2 = y.Item3;
a3 = x.Item4;
a4 = y.Item4;
return(a1 == z.Item1 && a2 == z.Item2 && a3 == z.Item3 && a4 == z.Item4);
};
if (!intTable.CheckUnpack(checkInt32))
{
PrintError(intTable, methodUnderTestName, "(int x, int y, int z, ref int a) => (a = x ^ y) == z", checkInt32);
testResult = Fail;
}
CheckMethodFourTFourU <uint, uint> checkUInt32 =
(ValueTuple <uint, uint, uint, uint> x, ValueTuple <uint, uint, uint, uint> y,
ValueTuple <uint, uint, uint, uint> z,
ref uint a1, ref uint a2, ref uint a3, ref uint a4) =>
{
a1 = x.Item3;
a2 = y.Item3;
a3 = x.Item4;
a4 = y.Item4;
return(a1 == z.Item1 && a2 == z.Item2 && a3 == z.Item3 && a4 == z.Item4);
};
if (!uintTable.CheckUnpack(checkUInt32))
{
PrintError(uintTable, methodUnderTestName, "(uint x, uint y, uint z, ref uint a) => (a = x ^ y) == z", checkUInt32);
testResult = Fail;
}
CheckMethodEightOfTEightOfU <short, short> checkInt16 =
(ValueTuple <short, short, short, short, short, short, short, ValueTuple <short> > x,
ValueTuple <short, short, short, short, short, short, short, ValueTuple <short> > y,
ValueTuple <short, short, short, short, short, short, short, ValueTuple <short> > z,
ref short a1, ref short a2, ref short a3, ref short a4, ref short a5, ref short a6, ref short a7, ref short a8) =>
{
a1 = x.Item5;
a2 = y.Item5;
a3 = x.Item6;
a4 = y.Item6;
a5 = x.Item7;
a6 = y.Item7;
a7 = x.Item8;
a8 = y.Item8;
return(a1 == z.Item1 && a2 == z.Item2 && a3 == z.Item3 && a4 == z.Item4 &&
a5 == z.Item5 && a6 == z.Item6 && a7 == z.Item7 && a8 == z.Item8);
};
if (!shortTable.CheckUnpack(checkInt16))
{
PrintError(shortTable, methodUnderTestName, "CheckUnpack(CheckMethodEightOfTEightOfU<short, short>)", checkInt16);
testResult = Fail;
}
CheckMethodEightOfTEightOfU <ushort, ushort> checkUInt16 =
(ValueTuple <ushort, ushort, ushort, ushort, ushort, ushort, ushort, ValueTuple <ushort> > x,
ValueTuple <ushort, ushort, ushort, ushort, ushort, ushort, ushort, ValueTuple <ushort> > y,
ValueTuple <ushort, ushort, ushort, ushort, ushort, ushort, ushort, ValueTuple <ushort> > z,
ref ushort a1, ref ushort a2, ref ushort a3, ref ushort a4, ref ushort a5, ref ushort a6, ref ushort a7, ref ushort a8) =>
{
a1 = x.Item5;
a2 = y.Item5;
a3 = x.Item6;
a4 = y.Item6;
a5 = x.Item7;
a6 = y.Item7;
a7 = x.Item8;
a8 = y.Item8;
return(a1 == z.Item1 && a2 == z.Item2 && a3 == z.Item3 && a4 == z.Item4 &&
a5 == z.Item5 && a6 == z.Item6 && a7 == z.Item7 && a8 == z.Item8);
};
if (!ushortTable.CheckUnpack(checkUInt16))
{
PrintError(ushortTable, methodUnderTestName, "(ushort x, ushort y, ushort z, ref ushort a) => (a = (ushort)(x ^ y)) == z", checkUInt16);
testResult = Fail;
}
CheckMethodSixteenOfAll <sbyte, sbyte> checkSByte =
(ValueTuple <sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, ValueTuple <sbyte> > x1,
ValueTuple <sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, ValueTuple <sbyte> > x,
ValueTuple <sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, ValueTuple <sbyte> > y1,
ValueTuple <sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, ValueTuple <sbyte> > y,
ValueTuple <sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, ValueTuple <sbyte> > z1,
ValueTuple <sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, ValueTuple <sbyte> > z2,
ref sbyte a1, ref sbyte a2, ref sbyte a3, ref sbyte a4, ref sbyte a5, ref sbyte a6, ref sbyte a7, ref sbyte a8,
ref sbyte a9, ref sbyte a10, ref sbyte a11, ref sbyte a12, ref sbyte a13, ref sbyte a14, ref sbyte a15, ref sbyte a16) =>
{
a1 = x.Item1;
a2 = y.Item1;
a3 = x.Item2;
a4 = y.Item2;
a5 = x.Item3;
a6 = y.Item3;
a7 = x.Item4;
a8 = y.Item4;
a9 = x.Item5;
a10 = y.Item5;
a11 = x.Item6;
a12 = y.Item6;
a13 = x.Item7;
a14 = y.Item7;
a15 = x.Item8;
a16 = y.Item8;
return(a1 == z1.Item1 && a2 == z1.Item2 && a3 == z1.Item3 && a4 == z1.Item4 &&
a5 == z1.Item5 && a6 == z1.Item6 && a7 == z1.Item7 && a8 == z1.Item8 &&
a9 == z2.Item1 && a10 == z2.Item2 && a11 == z2.Item3 && a12 == z2.Item4 &&
a13 == z2.Item5 && a14 == z2.Item6 && a15 == z2.Item7 && a16 == z2.Item8);
};
if (!sbyteTable.CheckUnpack(checkSByte))
{
PrintError(sbyteTable, methodUnderTestName, "(sbyte x, sbyte y, sbyte z, ref sbyte a) => (a = (sbyte)(x ^ y)) == z", checkSByte);
testResult = Fail;
}
CheckMethodSixteenOfAll <byte, byte> checkByte =
(ValueTuple <byte, byte, byte, byte, byte, byte, byte, ValueTuple <byte> > x1,
ValueTuple <byte, byte, byte, byte, byte, byte, byte, ValueTuple <byte> > x,
ValueTuple <byte, byte, byte, byte, byte, byte, byte, ValueTuple <byte> > y1,
ValueTuple <byte, byte, byte, byte, byte, byte, byte, ValueTuple <byte> > y,
ValueTuple <byte, byte, byte, byte, byte, byte, byte, ValueTuple <byte> > z1,
ValueTuple <byte, byte, byte, byte, byte, byte, byte, ValueTuple <byte> > z2,
ref byte a1, ref byte a2, ref byte a3, ref byte a4, ref byte a5, ref byte a6, ref byte a7, ref byte a8,
ref byte a9, ref byte a10, ref byte a11, ref byte a12, ref byte a13, ref byte a14, ref byte a15, ref byte a16) =>
{
a1 = x.Item1;
a2 = y.Item1;
a3 = x.Item2;
a4 = y.Item2;
a5 = x.Item3;
a6 = y.Item3;
a7 = x.Item4;
a8 = y.Item4;
a9 = x.Item5;
a10 = y.Item5;
a11 = x.Item6;
a12 = y.Item6;
a13 = x.Item7;
a14 = y.Item7;
a15 = x.Item8;
a16 = y.Item8;
return(a1 == z1.Item1 && a2 == z1.Item2 && a3 == z1.Item3 && a4 == z1.Item4 &&
a5 == z1.Item5 && a6 == z1.Item6 && a7 == z1.Item7 && a8 == z1.Item8 &&
a9 == z2.Item1 && a10 == z2.Item2 && a11 == z2.Item3 && a12 == z2.Item4 &&
a13 == z2.Item5 && a14 == z2.Item6 && a15 == z2.Item7 && a16 == z2.Item8);
};
if (!byteTable.CheckUnpack(checkByte))
{
PrintError(byteTable, methodUnderTestName, "(byte x, byte y, byte z, ref byte a) => (a = (byte)(x ^ y)) == z", checkByte);
testResult = Fail;
}
}
}
else
{
Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}");
}
return(testResult);
}
static unsafe int Main(string[] args)
{
int testResult = Pass;
int testCount = 16;
string methodUnderTestName = nameof(Sse2.Shuffle);
if (Sse2.IsSupported)
{
string[] permuteData = new string[]
{
"0b11100100", // identity
"0b00011011", // invert
"0b00000000", // broadcast element 0
"0b11111111", // broadcast element 3
"0b01010101", // broadcast element 1
"0b10101010", // broadcast element 2
"0b11011000", // swap middle elements
"0b00100111", // swap external elements
"0b10110001", // swap internal with external elements
"0b11110000", // divide everything between external elements
"0b10100101", // divide everything between internal elements
"0b00010100", // pattern (0, 1, 1, 0)
"0b10000010", // pattern (2, 0, 0, 2)
"0b11001100", // pattern (3, 0, 3, 0)
"0b01100110", // pattern (1, 2, 1, 2)
"0b10011001" // pattern (2, 1, 2, 1)
};
string[] permuteDouble = new string[]
{
"0b00",
"0b01",
"0b10",
"0b11",
};
using (var doubleTable = TestTableTuvImmSse2 <double, double, byte> .Create(permuteDouble.Length))
using (var intTable = TestTableTuvImmSse2 <int, int, byte> .Create(permuteData.Length))
using (var uintTable = TestTableTuvImmSse2 <uint, uint, byte> .Create(permuteData.Length))
{
// Vector128<double> tests
TestUtilities.InitializeWithElementNumberingModuloVectorLength <double>(
doubleTable.inArray1, 16, (int i, int elNo) =>
{
return((uint)i % 2);
});
TestUtilities.InitializeWithElementNumberingModuloVectorLength <double>(
doubleTable.inArray2, 16, (int i, int elNo) =>
{
return((uint)i % 2 + 10);
});
(Vector128 <double>, Vector128 <double>)valueDouble_0 = doubleTable[0];
Vector128 <double> resultDouble_0 = Sse2.Shuffle(valueDouble_0.Item1, valueDouble_0.Item2, (byte)0b00);
doubleTable.SetOutArray(resultDouble_0, 0, (byte)0b00);
(Vector128 <double>, Vector128 <double>)valueDouble_1 = doubleTable[1];
Vector128 <double> resultDouble_1 = Sse2.Shuffle(valueDouble_1.Item1, valueDouble_1.Item2, (byte)0b01);
doubleTable.SetOutArray(resultDouble_1, 1, (byte)0b01);
(Vector128 <double>, Vector128 <double>)valueDouble_2 = doubleTable[2];
Vector128 <double> resultDouble_2 = Sse2.Shuffle(valueDouble_2.Item1, valueDouble_2.Item2, (byte)0b10);
doubleTable.SetOutArray(resultDouble_2, 2, (byte)0b10);
(Vector128 <double>, Vector128 <double>)valueDouble_3 = doubleTable[3];
Vector128 <double> resultDouble_3 = Sse2.Shuffle(valueDouble_3.Item1, valueDouble_3.Item2, (byte)0b11);
doubleTable.SetOutArray(resultDouble_3, 3, (byte)0b11);
// Vector128<int> tests
TestUtilities.InitializeWithElementNumberingModuloVectorLength <uint>(
uintTable.inArray1, 16, (int i, int elNo) =>
{
return((uint)i % 4);
});
(Vector128 <int>, Vector128 <int>)valueInt32_0 = intTable[0];
Vector128 <int> resultInt32_0 = Sse2.Shuffle(valueInt32_0.Item1, (byte)0b11100100);
intTable.SetOutArray(resultInt32_0, 0, (byte)0b11100100);
(Vector128 <int>, Vector128 <int>)valueInt32_1 = intTable[1];
Vector128 <int> resultInt32_1 = Sse2.Shuffle(valueInt32_1.Item1, (byte)0b00011011);
intTable.SetOutArray(resultInt32_1, 1, (byte)0b00011011);
(Vector128 <int>, Vector128 <int>)valueInt32_2 = intTable[2];
Vector128 <int> resultInt32_2 = Sse2.Shuffle(valueInt32_2.Item1, (byte)0b00000000);
intTable.SetOutArray(resultInt32_2, 2, (byte)0b00000000);
(Vector128 <int>, Vector128 <int>)valueInt32_3 = intTable[3];
Vector128 <int> resultInt32_3 = Sse2.Shuffle(valueInt32_3.Item1, (byte)0b11111111);
intTable.SetOutArray(resultInt32_3, 3, (byte)0b11111111);
(Vector128 <int>, Vector128 <int>)valueInt32_4 = intTable[4];
Vector128 <int> resultInt32_4 = Sse2.Shuffle(valueInt32_4.Item1, (byte)0b01010101);
intTable.SetOutArray(resultInt32_4, 4, (byte)0b01010101);
(Vector128 <int>, Vector128 <int>)valueInt32_5 = intTable[5];
Vector128 <int> resultInt32_5 = Sse2.Shuffle(valueInt32_5.Item1, (byte)0b10101010);
intTable.SetOutArray(resultInt32_5, 5, (byte)0b10101010);
(Vector128 <int>, Vector128 <int>)valueInt32_6 = intTable[6];
Vector128 <int> resultInt32_6 = Sse2.Shuffle(valueInt32_6.Item1, (byte)0b11011000);
intTable.SetOutArray(resultInt32_6, 6, (byte)0b11011000);
(Vector128 <int>, Vector128 <int>)valueInt32_7 = intTable[7];
Vector128 <int> resultInt32_7 = Sse2.Shuffle(valueInt32_7.Item1, (byte)0b00100111);
intTable.SetOutArray(resultInt32_7, 7, (byte)0b00100111);
(Vector128 <int>, Vector128 <int>)valueInt32_8 = intTable[8];
Vector128 <int> resultInt32_8 = Sse2.Shuffle(valueInt32_8.Item1, (byte)0b10110001);
intTable.SetOutArray(resultInt32_8, 8, (byte)0b10110001);
(Vector128 <int>, Vector128 <int>)valueInt32_9 = intTable[9];
Vector128 <int> resultInt32_9 = Sse2.Shuffle(valueInt32_9.Item1, (byte)0b11110000);
intTable.SetOutArray(resultInt32_9, 9, (byte)0b11110000);
(Vector128 <int>, Vector128 <int>)valueInt32_10 = intTable[10];
Vector128 <int> resultInt32_10 = Sse2.Shuffle(valueInt32_10.Item1, (byte)0b10100101);
intTable.SetOutArray(resultInt32_10, 10, (byte)0b10100101);
(Vector128 <int>, Vector128 <int>)valueInt32_11 = intTable[11];
Vector128 <int> resultInt32_11 = Sse2.Shuffle(valueInt32_11.Item1, (byte)0b00010100);
intTable.SetOutArray(resultInt32_11, 11, (byte)0b00010100);
(Vector128 <int>, Vector128 <int>)valueInt32_12 = intTable[12];
Vector128 <int> resultInt32_12 = Sse2.Shuffle(valueInt32_12.Item1, (byte)0b10000010);
intTable.SetOutArray(resultInt32_12, 12, (byte)0b10000010);
(Vector128 <int>, Vector128 <int>)valueInt32_13 = intTable[13];
Vector128 <int> resultInt32_13 = Sse2.Shuffle(valueInt32_13.Item1, (byte)0b11001100);
intTable.SetOutArray(resultInt32_13, 13, (byte)0b11001100);
(Vector128 <int>, Vector128 <int>)valueInt32_14 = intTable[14];
Vector128 <int> resultInt32_14 = Sse2.Shuffle(valueInt32_14.Item1, (byte)0b01100110);
intTable.SetOutArray(resultInt32_14, 14, (byte)0b01100110);
(Vector128 <int>, Vector128 <int>)valueInt32_15 = intTable[15];
Vector128 <int> resultInt32_15 = Sse2.Shuffle(valueInt32_15.Item1, (byte)0b10011001);
intTable.SetOutArray(resultInt32_15, 15, (byte)0b10011001);
// Vector128<uint> tests
TestUtilities.InitializeWithElementNumberingModuloVectorLength <uint>(
uintTable.inArray1, 16, (int i, int elNo) =>
{
return((uint)i % 4);
});
(Vector128 <uint>, Vector128 <uint>)valueUInt32_0 = uintTable[0];
Vector128 <uint> resultUInt32_0 = Sse2.Shuffle(valueUInt32_0.Item1, (byte)0b11100100);
uintTable.SetOutArray(resultUInt32_0, 0, (byte)0b11100100);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_1 = uintTable[1];
Vector128 <uint> resultUInt32_1 = Sse2.Shuffle(valueUInt32_1.Item1, (byte)0b00011011);
uintTable.SetOutArray(resultUInt32_1, 1, (byte)0b00011011);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_2 = uintTable[2];
Vector128 <uint> resultUInt32_2 = Sse2.Shuffle(valueUInt32_2.Item1, (byte)0b00000000);
uintTable.SetOutArray(resultUInt32_2, 2, (byte)0b00000000);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_3 = uintTable[3];
Vector128 <uint> resultUInt32_3 = Sse2.Shuffle(valueUInt32_3.Item1, (byte)0b11111111);
uintTable.SetOutArray(resultUInt32_3, 3, (byte)0b11111111);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_4 = uintTable[4];
Vector128 <uint> resultUInt32_4 = Sse2.Shuffle(valueUInt32_4.Item1, (byte)0b01010101);
uintTable.SetOutArray(resultUInt32_4, 4, (byte)0b01010101);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_5 = uintTable[5];
Vector128 <uint> resultUInt32_5 = Sse2.Shuffle(valueUInt32_5.Item1, (byte)0b10101010);
uintTable.SetOutArray(resultUInt32_5, 5, (byte)0b10101010);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_6 = uintTable[6];
Vector128 <uint> resultUInt32_6 = Sse2.Shuffle(valueUInt32_6.Item1, (byte)0b11011000);
uintTable.SetOutArray(resultUInt32_6, 6, (byte)0b11011000);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_7 = uintTable[7];
Vector128 <uint> resultUInt32_7 = Sse2.Shuffle(valueUInt32_7.Item1, (byte)0b00100111);
uintTable.SetOutArray(resultUInt32_7, 7, (byte)0b00100111);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_8 = uintTable[8];
Vector128 <uint> resultUInt32_8 = Sse2.Shuffle(valueUInt32_8.Item1, (byte)0b10110001);
uintTable.SetOutArray(resultUInt32_8, 8, (byte)0b10110001);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_9 = uintTable[9];
Vector128 <uint> resultUInt32_9 = Sse2.Shuffle(valueUInt32_9.Item1, (byte)0b11110000);
uintTable.SetOutArray(resultUInt32_9, 9, (byte)0b11110000);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_10 = uintTable[10];
Vector128 <uint> resultUInt32_10 = Sse2.Shuffle(valueUInt32_10.Item1, (byte)0b10100101);
uintTable.SetOutArray(resultUInt32_10, 10, (byte)0b10100101);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_11 = uintTable[11];
Vector128 <uint> resultUInt32_11 = Sse2.Shuffle(valueUInt32_11.Item1, (byte)0b00010100);
uintTable.SetOutArray(resultUInt32_11, 11, (byte)0b00010100);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_12 = uintTable[12];
Vector128 <uint> resultUInt32_12 = Sse2.Shuffle(valueUInt32_12.Item1, (byte)0b10000010);
uintTable.SetOutArray(resultUInt32_12, 12, (byte)0b10000010);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_13 = uintTable[13];
Vector128 <uint> resultUInt32_13 = Sse2.Shuffle(valueUInt32_13.Item1, (byte)0b11001100);
uintTable.SetOutArray(resultUInt32_13, 13, (byte)0b11001100);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_14 = uintTable[14];
Vector128 <uint> resultUInt32_14 = Sse2.Shuffle(valueUInt32_14.Item1, (byte)0b01100110);
uintTable.SetOutArray(resultUInt32_14, 14, (byte)0b01100110);
(Vector128 <uint>, Vector128 <uint>)valueUInt32_15 = uintTable[15];
Vector128 <uint> resultUInt32_15 = Sse2.Shuffle(valueUInt32_15.Item1, (byte)0b10011001);
uintTable.SetOutArray(resultUInt32_15, 15, (byte)0b10011001);
CheckMethodFiveDouble <double, double, byte> checkDouble =
(Span <double> x, Span <double> y, byte imm, Span <double> z, Span <double> a) =>
{
a[0] = (0x01 & imm) > 0 ? x[1] : x[0];
a[1] = (0x02 & imm) > 0 ? y[1] : y[0];
return(a[0] == z[0] && a[1] == z[1]);
};
if (!doubleTable.CheckResultShuffle(checkDouble))
{
PrintError8(doubleTable, methodUnderTestName, "(double x, byte y, double z, ref double a) => (a = x * y) == z", checkDouble);
testResult = Fail;
}
CheckMethodFive <int, int, byte> checkInt32 = (Span <int> x, byte imm, Span <int> z, Span <int> a) =>
{
bool result = true;
for (int i = 0; i < x.Length; i++)
{
a[i] = x[imm & 0x03];
if (z[i] != a[i])
{
result = false;
}
imm = (byte)(imm >> 2);
}
return(result);
};
if (!intTable.CheckResultShuffle(checkInt32))
{
PrintError(intTable, methodUnderTestName, "(int x, byte y, int z, ref int a) => (a = x << y) == z", checkInt32);
testResult = Fail;
}
CheckMethodFive <uint, uint, byte> checkUInt32 = (Span <uint> x, byte imm, Span <uint> z, Span <uint> a) =>
{
bool result = true;
for (int i = 0; i < x.Length; i++)
{
a[i] = x[imm & 0x03];
if (z[i] != a[i])
{
result = false;
}
imm = (byte)(imm >> 2);
}
return(result);
};
if (!uintTable.CheckResultShuffle(checkUInt32))
{
PrintError(uintTable, methodUnderTestName, "(uint x, byte y, uint z, ref uint a) => (a = x << y) == z", checkUInt32);
testResult = Fail;
}
}
}
else
{
Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}");
}
return(testResult);
}
static unsafe int Main(string[] args)
{
short testResult = Pass;
short testsCount = 16;
string methodUnderTestName = nameof(Sse2.ShuffleLow);
if (Sse2.IsSupported)
{
string[] permuteData = new string[]
{
"0b11100100", // identity
"0b00011011", // invert
"0b00000000", // broadcast element 0
"0b11111111", // broadcast element 3
"0b01010101", // broadcast element 1
"0b10101010", // broadcast element 2
"0b11011000", // swap middle elements
"0b00100111", // swap external elements
"0b10110001", // swap internal with external elements
"0b11110000", // divide everything between external elements
"0b10100101", // divide everything between internal elements
"0b00010100", // pattern (0, 1, 1, 0)
"0b10000010", // pattern (2, 0, 0, 2)
"0b11001100", // pattern (3, 0, 3, 0)
"0b01100110", // pattern (1, 2, 1, 2)
"0b10011001" // pattern (2, 1, 2, 1)
};
using (var shortTable = TestTableTuvImmSse2 <short, short, byte> .Create(testsCount))
using (var ushortTable = TestTableTuvImmSse2 <ushort, ushort, byte> .Create(testsCount))
{
// Vector128<short> tests
TestUtilities.InitializeWithElementNumberingModuloVectorLength <short>(
shortTable.inArray1, 16, (int i, int elNo) =>
{
return((short)(i % 8));
});
TestUtilities.InitializeWithConstValue <short>(0, shortTable.inArray2);
(Vector128 <short>, Vector128 <short>)valueInt16_0 = shortTable[0];
Vector128 <short> resultInt16_0 = Sse2.ShuffleLow(valueInt16_0.Item1, (byte)0b11100100);
shortTable.SetOutArray(resultInt16_0, 0, (byte)0b11100100);
(Vector128 <short>, Vector128 <short>)valueInt16_1 = shortTable[1];
Vector128 <short> resultInt16_1 = Sse2.ShuffleLow(valueInt16_1.Item1, (byte)0b00011011);
shortTable.SetOutArray(resultInt16_1, 1, (byte)0b00011011);
(Vector128 <short>, Vector128 <short>)valueInt16_2 = shortTable[2];
Vector128 <short> resultInt16_2 = Sse2.ShuffleLow(valueInt16_2.Item1, (byte)0b00000000);
shortTable.SetOutArray(resultInt16_2, 2, (byte)0b00000000);
(Vector128 <short>, Vector128 <short>)valueInt16_3 = shortTable[3];
Vector128 <short> resultInt16_3 = Sse2.ShuffleLow(valueInt16_3.Item1, (byte)0b11111111);
shortTable.SetOutArray(resultInt16_3, 3, (byte)0b11111111);
(Vector128 <short>, Vector128 <short>)valueInt16_4 = shortTable[4];
Vector128 <short> resultInt16_4 = Sse2.ShuffleLow(valueInt16_4.Item1, (byte)0b01010101);
shortTable.SetOutArray(resultInt16_4, 4, (byte)0b01010101);
(Vector128 <short>, Vector128 <short>)valueInt16_5 = shortTable[5];
Vector128 <short> resultInt16_5 = Sse2.ShuffleLow(valueInt16_5.Item1, (byte)0b10101010);
shortTable.SetOutArray(resultInt16_5, 5, (byte)0b10101010);
(Vector128 <short>, Vector128 <short>)valueInt16_6 = shortTable[6];
Vector128 <short> resultInt16_6 = Sse2.ShuffleLow(valueInt16_6.Item1, (byte)0b11011000);
shortTable.SetOutArray(resultInt16_6, 6, (byte)0b11011000);
(Vector128 <short>, Vector128 <short>)valueInt16_7 = shortTable[7];
Vector128 <short> resultInt16_7 = Sse2.ShuffleLow(valueInt16_7.Item1, (byte)0b00100111);
shortTable.SetOutArray(resultInt16_7, 7, (byte)0b00100111);
(Vector128 <short>, Vector128 <short>)valueInt16_8 = shortTable[8];
Vector128 <short> resultInt16_8 = Sse2.ShuffleLow(valueInt16_8.Item1, (byte)0b10110001);
shortTable.SetOutArray(resultInt16_8, 8, (byte)0b10110001);
(Vector128 <short>, Vector128 <short>)valueInt16_9 = shortTable[9];
Vector128 <short> resultInt16_9 = Sse2.ShuffleLow(valueInt16_9.Item1, (byte)0b11110000);
shortTable.SetOutArray(resultInt16_9, 9, (byte)0b11110000);
(Vector128 <short>, Vector128 <short>)valueInt16_10 = shortTable[10];
Vector128 <short> resultInt16_10 = Sse2.ShuffleLow(valueInt16_10.Item1, (byte)0b10100101);
shortTable.SetOutArray(resultInt16_10, 10, (byte)0b10100101);
(Vector128 <short>, Vector128 <short>)valueInt16_11 = shortTable[11];
Vector128 <short> resultInt16_11 = Sse2.ShuffleLow(valueInt16_11.Item1, (byte)0b00010100);
shortTable.SetOutArray(resultInt16_11, 11, (byte)0b00010100);
(Vector128 <short>, Vector128 <short>)valueInt16_12 = shortTable[12];
Vector128 <short> resultInt16_12 = Sse2.ShuffleLow(valueInt16_12.Item1, (byte)0b10000010);
shortTable.SetOutArray(resultInt16_12, 12, (byte)0b10000010);
(Vector128 <short>, Vector128 <short>)valueInt16_13 = shortTable[13];
Vector128 <short> resultInt16_13 = Sse2.ShuffleLow(valueInt16_13.Item1, (byte)0b11001100);
shortTable.SetOutArray(resultInt16_13, 13, (byte)0b11001100);
(Vector128 <short>, Vector128 <short>)valueInt16_14 = shortTable[14];
Vector128 <short> resultInt16_14 = Sse2.ShuffleLow(valueInt16_14.Item1, (byte)0b01100110);
shortTable.SetOutArray(resultInt16_14, 14, (byte)0b01100110);
(Vector128 <short>, Vector128 <short>)valueInt16_15 = shortTable[15];
Vector128 <short> resultInt16_15 = Sse2.ShuffleLow(valueInt16_15.Item1, (byte)0b10011001);
shortTable.SetOutArray(resultInt16_15, 15, (byte)0b10011001);
// Vector128<ushort> tests
TestUtilities.InitializeWithElementNumberingModuloVectorLength <ushort>(
ushortTable.inArray1, 16, (int i, int elNo) =>
{
return((ushort)(i % 8));
});
TestUtilities.InitializeWithConstValue <ushort>(0, ushortTable.inArray2);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_0 = ushortTable[0];
Vector128 <ushort> resultUInt16_0 = Sse2.ShuffleLow(valueUInt16_0.Item1, (byte)0b11100100);
ushortTable.SetOutArray(resultUInt16_0, 0, (byte)0b11100100);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_1 = ushortTable[1];
Vector128 <ushort> resultUInt16_1 = Sse2.ShuffleLow(valueUInt16_1.Item1, (byte)0b00011011);
ushortTable.SetOutArray(resultUInt16_1, 1, (byte)0b00011011);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_2 = ushortTable[2];
Vector128 <ushort> resultUInt16_2 = Sse2.ShuffleLow(valueUInt16_2.Item1, (byte)0b00000000);
ushortTable.SetOutArray(resultUInt16_2, 2, (byte)0b00000000);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_3 = ushortTable[3];
Vector128 <ushort> resultUInt16_3 = Sse2.ShuffleLow(valueUInt16_3.Item1, (byte)0b11111111);
ushortTable.SetOutArray(resultUInt16_3, 3, (byte)0b11111111);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_4 = ushortTable[4];
Vector128 <ushort> resultUInt16_4 = Sse2.ShuffleLow(valueUInt16_4.Item1, (byte)0b01010101);
ushortTable.SetOutArray(resultUInt16_4, 4, (byte)0b01010101);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_5 = ushortTable[5];
Vector128 <ushort> resultUInt16_5 = Sse2.ShuffleLow(valueUInt16_5.Item1, (byte)0b10101010);
ushortTable.SetOutArray(resultUInt16_5, 5, (byte)0b10101010);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_6 = ushortTable[6];
Vector128 <ushort> resultUInt16_6 = Sse2.ShuffleLow(valueUInt16_6.Item1, (byte)0b11011000);
ushortTable.SetOutArray(resultUInt16_6, 6, (byte)0b11011000);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_7 = ushortTable[7];
Vector128 <ushort> resultUInt16_7 = Sse2.ShuffleLow(valueUInt16_7.Item1, (byte)0b00100111);
ushortTable.SetOutArray(resultUInt16_7, 7, (byte)0b00100111);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_8 = ushortTable[8];
Vector128 <ushort> resultUInt16_8 = Sse2.ShuffleLow(valueUInt16_8.Item1, (byte)0b10110001);
ushortTable.SetOutArray(resultUInt16_8, 8, (byte)0b10110001);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_9 = ushortTable[9];
Vector128 <ushort> resultUInt16_9 = Sse2.ShuffleLow(valueUInt16_9.Item1, (byte)0b11110000);
ushortTable.SetOutArray(resultUInt16_9, 9, (byte)0b11110000);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_10 = ushortTable[10];
Vector128 <ushort> resultUInt16_10 = Sse2.ShuffleLow(valueUInt16_10.Item1, (byte)0b10100101);
ushortTable.SetOutArray(resultUInt16_10, 10, (byte)0b10100101);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_11 = ushortTable[11];
Vector128 <ushort> resultUInt16_11 = Sse2.ShuffleLow(valueUInt16_11.Item1, (byte)0b00010100);
ushortTable.SetOutArray(resultUInt16_11, 11, (byte)0b00010100);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_12 = ushortTable[12];
Vector128 <ushort> resultUInt16_12 = Sse2.ShuffleLow(valueUInt16_12.Item1, (byte)0b10000010);
ushortTable.SetOutArray(resultUInt16_12, 12, (byte)0b10000010);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_13 = ushortTable[13];
Vector128 <ushort> resultUInt16_13 = Sse2.ShuffleLow(valueUInt16_13.Item1, (byte)0b11001100);
ushortTable.SetOutArray(resultUInt16_13, 13, (byte)0b11001100);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_14 = ushortTable[14];
Vector128 <ushort> resultUInt16_14 = Sse2.ShuffleLow(valueUInt16_14.Item1, (byte)0b01100110);
ushortTable.SetOutArray(resultUInt16_14, 14, (byte)0b01100110);
(Vector128 <ushort>, Vector128 <ushort>)valueUInt16_15 = ushortTable[15];
Vector128 <ushort> resultUInt16_15 = Sse2.ShuffleLow(valueUInt16_15.Item1, (byte)0b10011001);
ushortTable.SetOutArray(resultUInt16_15, 15, (byte)0b10011001);
CheckMethodFive <short, short, byte> checkInt16 = (Span <short> x, byte imm, Span <short> z, Span <short> a) =>
{
bool result = true;
int halfLength = x.Length / 2;
for (int i = 0; i < x.Length; i++)
{
if (i >= halfLength)
{
a[i] = x[i];
}
else
{
a[i] = x[(imm & 0x03)];
imm = (byte)(imm >> 2);
}
if (z[i] != a[i])
{
result = false;
}
}
return(result);
};
if (!shortTable.CheckResultShuffle(checkInt16))
{
PrintError8(shortTable, methodUnderTestName, "CheckResultShuffleHigh", checkInt16);
testResult = Fail;
}
CheckMethodFive <ushort, ushort, byte> checkUInt16 = (Span <ushort> x, byte imm, Span <ushort> z, Span <ushort> a) =>
{
bool result = true;
int halfLength = x.Length / 2;
for (int i = 0; i < x.Length; i++)
{
if (i >= halfLength)
{
a[i] = x[i];
}
else
{
a[i] = x[(imm & 0x03)];
imm = (byte)(imm >> 2);
}
if (z[i] != a[i])
{
result = false;
}
}
return(result);
};
if (!ushortTable.CheckResultShuffle(checkUInt16))
{
PrintError8(ushortTable, methodUnderTestName, "CheckResultShuffleHigh", checkUInt16);
testResult = Fail;
}
}
}
else
{
Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}");
}
return(testResult);
}
