public void max128_i32()
{
var blocklen = Span128 <int> .BlockLength;
var lhs = Random.ReadOnlySpan128 <int>(SampleSize);
var rhs = Random.ReadOnlySpan128 <int>(SampleSize);
var expect = Span128.AllocBlocks <int>(SampleSize);
var actual = Span128.AllocBlocks <int>(SampleSize);
for (var block = 0; block < SampleSize; block++)
{
var offset = block * blocklen;
Span <int> tmp = stackalloc int[blocklen];
for (var i = 0; i < blocklen; i++)
{
tmp[i] = gmath.max(lhs[offset + i], rhs[offset + i]);
}
var vExpect = Vec128.LoadVector(ref tmp[0]);
var vX = lhs.LoadVec128(block);
var vY = rhs.LoadVec128(block);
var vActual = ginx.max <int>(vX, vY);
Claim.eq(vExpect, vActual);
vstore(vExpect, ref expect.Block(block));
vstore(vActual, ref actual.Block(block));
}
Claim.eq(expect, actual);
}
public void CreateScalars()
{
{
var vec1 = Vec128.FromParts(2, 0, 3, 0);
var vec2 = Vec128.FromParts(5, 0, 7, 0);
var expect = Vec128.FromParts(10L, 21L);
var result = Vec128 <long> .Zero;
result = dinx.mul(vec1, vec2);
Claim.eq(expect, result);
}
{
var vec1 = Vec128.FromParts(2, 0, 3, 0);
var vec2 = Vec128.FromParts(5, 0, 7, 0);
var result = Vec128 <long> .Zero;
result = dinx.mul(vec1, vec2);
var expect = Vec128.FromParts(vec1.ToScalar128(0) * vec2.ToScalar128(0), vec1.ToScalar128(2) * vec2.ToScalar128(2));
Claim.eq(expect, result);
}
{
var vec1 = Vec128.FromParts(2.0f, 3.0f, 4.0f, 5.0f);
var vec2 = Vec128.FromParts(5.0f, 2.0f, 8.0f, 4.0f);
var expect = Vec128.FromParts(10.0f, 6.0f, 32.0f, 20.0f);
var result = Vec128 <float> .Zero;
result = dfp.fmul(vec1, vec2);
Claim.eq(expect, result);
}
}
public void permute128i32()
{
var id = Vec128.FromParts(0, 1, 2, 3);
Claim.eq(dinx.permute(id, Perm4.ADCB), Vec128.FromParts(0, 3, 2, 1));
Claim.eq(dinx.permute(id, Perm4.DBCA), Vec128.FromParts(3, 1, 2, 0));
Permute4i32();
}
public void increments_128x16u()
{
var v1 = Vec128.Increments((ushort)0);
var v2 = Vec128.Decrements((ushort)7);
var v3 = reverse_check(v1);
Claim.eq(v2, v3);
}
public void shuffle_128x8u()
{
var mask = Vec128.Fill((byte)0b10000000);
var src = Random.CpuVec128 <byte>();
var dst = dinx.shuffle(in src, in mask);
var zed = Vec128.Fill((byte)0);
Claim.eq(dst, zed);
}
// Test case taken from https://docs.microsoft.com/en-us/previous-versions/bb514073(v=vs.120)
public void testz128i32()
{
var a = Vec128.FromParts(0x55550000BBBB9999ul, 0x0123456789ABCDEFul);
var b = Vec128.FromParts(0xAAAAFFFF44446666ul, 0xFEDCBA9876543210ul);
var c = Vec128.FromParts(0x55550000BBCB9999ul, 0x0123456789ABCDEFul);
Claim.yea(dinx.testz(a, b));
Claim.nea(dinx.testz(c, b));
}
public void Nonzero()
{
Claim.yea(gbits.nonz(Vec256.FromParts(1ul, 2ul, 3ul, 4ul)));
Claim.yea(gbits.nonz(Vec256.FromParts(1ul, 0ul, 0ul, 0ul)));
Claim.nea(gbits.nonz(Vec256.FromParts(0ul, 0ul, 0ul, 0ul)));
Claim.yea(gbits.nonz(Vec128.FromParts(1u, 2u, 3u, 4u)));
Claim.yea(gbits.nonz(Vec128.FromParts(1u, 0u, 0u, 0u)));
Claim.nea(gbits.nonz(Vec128.FromParts(0u, 0u, 0u, 0u)));
}
public void arrange_128_i32()
{
var u = Vec128Pattern.Increments <int>();
Claim.eq(Vec128.FromParts(0, 1, 2, 3), u);
var v = Vec128Pattern.Decrements <int>(3);
Claim.eq(Vec128.FromParts(3, 2, 1, 0), v);
Claim.eq(v, Arrange.shuffle(u, Perm4.DCBA));
Claim.eq(u, Arrange.shuffle(v, Perm4.DCBA));
}
void Flip128 <T>()
where T : unmanaged
{
TypeCaseStart <T>();
for (var i = 0; i < Pow2.T06; i++)
{
var src = Random.CpuVec128 <T>();
var srcData = src.ToSpan();
var expect = Vec128.Load(ref mathspan.flip(srcData)[0]);
var actual = gbits.flip(in src);
Claim.yea(expect.Equals(actual));
}
TypeCaseEnd <T>();
}
void nonzero128_check <T>()
where T : unmanaged
{
TypeCaseStart <T>();
var src = Random.Span128 <T>(blocks: SampleSize);
for (var i = 0; i < src.BlockCount; i++)
{
var v = Vec128.Load(ref src.Block(i));
Claim.yea(gbits.nonz(v));
}
Claim.nea(gbits.nonz(Vec128.Zero <T>()));
TypeCaseEnd <T>();
}
public static void vstore <T>(Vec128 <T> src, ref T dst)
where T : struct
{
if (typeof(T) == typeof(sbyte))
{
vstore(int8(src), ref int8(ref dst));
}
else if (typeof(T) == typeof(byte))
{
vstore(uint8(src), ref uint8(ref dst));
}
else if (typeof(T) == typeof(short))
{
vstore(int16(src), ref int16(ref dst));
}
else if (typeof(T) == typeof(ushort))
{
vstore(uint16(src), ref uint16(ref dst));
}
else if (typeof(T) == typeof(int))
{
vstore(int32(src), ref int32(ref dst));
}
else if (typeof(T) == typeof(uint))
{
vstore(uint32(src), ref uint32(ref dst));
}
else if (typeof(T) == typeof(long))
{
vstore(int64(src), ref int64(ref dst));
}
else if (typeof(T) == typeof(ulong))
{
vstore(uint64(src), ref uint64(ref dst));
}
else if (typeof(T) == typeof(float))
{
vstore(float32(src), ref float32(ref dst));
}
else if (typeof(T) == typeof(double))
{
vstore(float64(src), ref float64(ref dst));
}
else
{
throw unsupported <T>();
}
}
public void shuffle128i32()
{
var v1 = Vec128.FromParts(0, 1, 2, 3);
//Produces the identity permutation
var m1 = (byte)0b11_10_01_00;
//Reversal
var m2 = (byte)0b00_01_10_11;
//RotL(1)
var m3 = (byte)0b10_01_00_11;
var s1 = dinx.shuffle(v1, m1);
var s2 = dinx.shuffle(v1, m2);
var s3 = dinx.shuffle(v1, m3);
}
public void perm_swaps()
{
var src = Vec128.Increments((byte)0);
Swap s = (0, 1);
var x1 = dinx.swap(src, s);
var x2 = dinx.swap(x1, s);
Claim.eq(x2, src);
//Shuffle the first element all the way through to the last element
var chain = Swap.Chain((0, 1), 15);
var x3 = dinx.swap(src, chain);
//Trace($"{chain.Format()} |> {src.FormatHex()} = {x3.FormatHex()}");
Claim.eq(x3[15], (byte)0);
}
void Permute4i32(int cycles = DefaltCycleCount, bool trace = false)
{
var pSrc = Random.EnumStream <Perm4>(x => (byte)x > 5);
for (var i = 0; i < cycles; i++)
{
var v1 = Random.CpuVec128 <int>();
var p = pSrc.First();
// Disassemble the spec
var p0 = Bits.gather((byte)p, (byte)0b11);
var p1 = Bits.gather((byte)p, (byte)0b1100);
var p2 = Bits.gather((byte)p, (byte)0b110000);
var p3 = Bits.gather((byte)p, (byte)0b11000000);
// Reassemble the spec
Perm4 q = (Perm4)(p0 | p1 << 2 | p2 << 4 | p3 << 6);
// Same?
Claim.eq(p, q);
// Permute vector via api
var v2 = dinx.permute(v1, p);
// Permute vector manually
var v3 = Vec128.FromParts(v1[p0], v1[p1], v1[p2], v1[p3]);
// Same?
Claim.eq(v3, v2);
if (trace)
{
Trace("v1", v1.FormatHex());
Trace("p", p.Format());
Trace("perm(v1,p)", v2.FormatHex());
}
}
}
static unsafe void vstore(Vec128 <byte> src, ref byte dst) => Store(refptr(ref dst), src);
public void shuffle_128x16u()
{
var id = Vec128.FromParts(0, 1, 2, 3, 6, 7, 8, 9);
Claim.eq(Arrange.shuffle(id, Perm4.ADCB, Perm4.ADCB), Vec128.FromParts(0, 3, 2, 1, 6, 9, 8, 7));
}
static unsafe void vstore(Vec128 <short> src, ref short dst) => Store(refptr(ref dst), src);
static unsafe void vstore(Vec128 <uint> src, ref uint dst) => Store(refptr(ref dst), src);
static unsafe void vstore(Vec128 <ulong> src, ref ulong dst) => Store(refptr(ref dst), src);
static unsafe void vstore(Vec128 <float> src, ref float dst) => Store(refptr(ref dst), src);
static unsafe void vstore(Vec128 <double> src, ref double dst) => Store(refptr(ref dst), src);
