public void BlockCount()
{
Claim.eq(1, Span128.WholeBlocks <sbyte>(16));
Claim.eq(1, Span128.WholeBlocks <byte>(16));
Claim.eq(1, Span128.WholeBlocks <short>(8));
Claim.eq(1, Span128.WholeBlocks <ushort>(8));
Claim.eq(1, Span128.WholeBlocks <int>(4));
Claim.eq(1, Span128.WholeBlocks <uint>(4));
Claim.eq(1, Span128.WholeBlocks <float>(4));
Claim.eq(1, Span128.WholeBlocks <long>(2));
Claim.eq(1, Span128.WholeBlocks <ulong>(2));
Claim.eq(1, Span128.WholeBlocks <double>(2));
Claim.eq(1, Span256.WholeBlocks <sbyte>(32));
Claim.eq(1, Span256.WholeBlocks <byte>(32));
Claim.eq(1, Span256.WholeBlocks <short>(16));
Claim.eq(1, Span256.WholeBlocks <ushort>(16));
Claim.eq(1, Span256.WholeBlocks <int>(8));
Claim.eq(1, Span256.WholeBlocks <uint>(8));
Claim.eq(1, Span256.WholeBlocks <float>(8));
Claim.eq(1, Span256.WholeBlocks <long>(4));
Claim.eq(1, Span256.WholeBlocks <ulong>(4));
Claim.eq(1, Span256.WholeBlocks <double>(4));
}
public void max256_i32()
{
var blocklen = Span256 <int> .BlockLength;
var lhs = Random.ReadOnlySpan256 <int>(SampleSize);
var rhs = Random.ReadOnlySpan256 <int>(SampleSize);
var expect = Span256.AllocBlocks <int>(SampleSize);
var actual = Span256.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 = Vec256.LoadVector(ref tmp[0]);
var vX = lhs.LoadVec256(block);
var vY = rhs.LoadVec256(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 BlockLength()
{
Claim.eq(4, Span128 <int> .BlockLength);
Claim.eq(16, Span128.BlockLength <sbyte>());
Claim.eq(16, Span128.BlockLength <byte>());
Claim.eq(8, Span128.BlockLength <short>());
Claim.eq(8, Span128.BlockLength <ushort>());
Claim.eq(4, Span128.BlockLength <int>());
Claim.eq(4, Span128.BlockLength <uint>());
Claim.eq(2, Span128.BlockLength <long>());
Claim.eq(2, Span128.BlockLength <ulong>());
Claim.eq(4, Span128.BlockLength <float>());
Claim.eq(2, Span128.BlockLength <double>());
Claim.eq(8, Span128.BlockLength <int>(2));
Claim.eq(4, Span128.BlockLength <long>(2));
Claim.eq(32, Span128.BlockLength <byte>(2));
Claim.eq(8, Span256 <int> .BlockLength);
Claim.eq(32, Span256.BlockLength <sbyte>());
Claim.eq(32, Span256.BlockLength <byte>());
Claim.eq(16, Span256.BlockLength <short>());
Claim.eq(16, Span256.BlockLength <ushort>());
Claim.eq(8, Span256.BlockLength <int>());
Claim.eq(8, Span256.BlockLength <uint>());
Claim.eq(4, Span256.BlockLength <long>());
Claim.eq(4, Span256.BlockLength <ulong>());
Claim.eq(8, Span256.BlockLength <float>());
Claim.eq(4, Span256.BlockLength <double>());
}
public void CellSize()
{
Claim.eq(4, Span128 <int> .CellSize);
Claim.eq(1, Span128.CellSize <sbyte>());
Claim.eq(1, Span128.CellSize <byte>());
Claim.eq(2, Span128.CellSize <short>());
Claim.eq(4, Span128.CellSize <int>());
Claim.eq(4, Span128.CellSize <uint>());
Claim.eq(4, Span128.CellSize <float>());
Claim.eq(8, Span128.CellSize <ulong>());
Claim.eq(8, Span128.CellSize <double>());
Claim.eq(8, Span128.CellSize <long>());
Claim.eq(4, Span256 <int> .CellSize);
Claim.eq(1, Span256.CellSize <sbyte>());
Claim.eq(1, Span256.CellSize <byte>());
Claim.eq(2, Span256.CellSize <short>());
Claim.eq(4, Span256.CellSize <int>());
Claim.eq(4, Span256.CellSize <uint>());
Claim.eq(4, Span256.CellSize <float>());
Claim.eq(8, Span256.CellSize <ulong>());
Claim.eq(8, Span256.CellSize <double>());
Claim.eq(8, Span256.CellSize <long>());
}
public static Span256 <T> convert <S, T>(Span256 <S> src)
where T : struct
where S : struct
{
var dst = Span256.Alloc <T>(src.Length);
for (var i = 0; i < src.Length; i++)
{
dst[i] = convert <S, T>(src[i]);
}
return(dst);
}
void sub256_batch_check <T>()
where T : unmanaged
{
TypeCaseStart <T>();
var lhs = Random.Span256 <T>(SampleSize).ReadOnly();
var rhs = Random.Span256 <T>(SampleSize).ReadOnly();
var dstA = ginx.sub(lhs, rhs, lhs.Replicate());
var dstB = Span256.AllocBlocks <T>(lhs.BlockCount);
for (var i = 0; i < dstA.Length; i++)
{
dstB[i] = gmath.sub(lhs[i], rhs[i]);
}
Claim.yea(dstA.Identical(dstB));
TypeCaseEnd <T>();
}
static Vec256 <T> BlendAltMask <T>()
where T : unmanaged
{
Span256 <T> mask = Span256.Alloc <T>(1);
var no = PrimalInfo.Get <T>().MaxVal;
var yes = PrimalInfo.Get <T>().Zero;
for (byte i = 0; i < mask.Length; i++)
{
if (i % 2 == 0)
{
mask[i] = yes;
}
else
{
mask[i] = no;
}
}
return(Vec256.Load(mask));
}
static Vec256 <byte> ShuffleIdentityMask()
{
Span256 <byte> mask = Span256.Alloc <byte>(1);
//For the first 128-bit lane
var half = mask.Length / 2;
for (byte i = 0; i < half; i++)
{
mask[i] = i;
}
//For the second 128-bit lane
for (byte i = 0; i < half; i++)
{
mask[i + half] = i;
}
return(Vec256.Load(mask));
}
public void BlockSize()
{
Claim.eq(16, Span128 <int> .BlockSize);
Claim.eq(16, Span128.BlockSize <sbyte>());
Claim.eq(16, Span128.BlockSize <byte>());
Claim.eq(16, Span128.BlockSize <short>());
Claim.eq(16, Span128.BlockSize <int>());
Claim.eq(16, Span128.BlockSize <float>());
Claim.eq(16, Span128.BlockSize <double>());
Claim.eq(16, Span128.BlockSize <long>());
Claim.eq(32, Span256 <int> .BlockSize);
Claim.eq(32, Span256.BlockSize <sbyte>());
Claim.eq(32, Span256.BlockSize <byte>());
Claim.eq(32, Span256.BlockSize <short>());
Claim.eq(32, Span256.BlockSize <int>());
Claim.eq(32, Span256.BlockSize <float>());
Claim.eq(32, Span256.BlockSize <double>());
Claim.eq(32, Span256.BlockSize <long>());
}
// Truncates alternating source vector components
static Vec256 <T> ShuffleTruncateMask <T>()
where T : unmanaged
{
var mask = Span256.Alloc <T>(1);
var chop = PrimalInfo.Get <T>().MaxVal;
//For the first 128-bit lane
var half = mask.Length / 2;
for (byte i = 0; i < half; i++)
{
if (i % 2 != 0)
{
mask[i] = chop;
}
else
{
mask[i] = convert <byte, T>(i);
}
}
//For the second 128-bit lane
for (byte i = 0; i < half; i++)
{
if (i % 2 != 0)
{
mask[i + half] = chop;
}
else
{
mask[i + half] = convert <byte, T>(i);
}
}
return(Vec256.Load(mask));
}
public void blend_256_u8()
{
void Test1()
{
var v0 = Random.CpuVec256 <byte>();
var v1 = Random.CpuVec256 <byte>();
var bits = Random.BitString <N32>();
var mask = Vec256.Load(bits.Map(x => x ? (byte)0xFF : (byte)0));
var v3 = dinx.blendv(v0, v1, mask);
var selection = Span256.AllocBlocks <byte>(1);
for (var i = 0; i < selection.Length; i++)
{
selection[i] = bits[i] ? v1[i] : v0[i];
}
var v4 = selection.ToCpuVec256();
Claim.eq(v3, v4);
}
Verify(Test1);
var v1 = Vec256.Fill <byte>(3);
var v2 = Vec256.Fill <byte>(4);
var control = Vec256Pattern.Alternate <byte>(0, 0xFF);
var v3 = dinx.blendv(v1, v2, control);
var block = Span256.AllocBlocks <byte>(1);
for (var i = 0; i < 32; i++)
{
block[i] = (byte)(even(i) ? 3 : 4);
}
var v4 = block.ToCpuVec256();
Claim.eq(v3, v4);
}
public static EigenResult <N, T> Define <N, T>(Span <N, Complex <T> > values, Span256 <T> lv = default, Span256 <T> rv = default)
where N : ITypeNat, new()
where T : struct
=> new EigenResult <N, T>(values, lv, rv);
