static Vec256 <T> ClearAlternating()
{
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));
}
void RunMultiply(int opcount = Pow2.T16)
{
var lhsSrc = Random.Stream <ulong>();
var rhsSrc = Random.Stream <ulong>();
var len = Vec256 <ulong> .Length;
var sw = stopwatch(false);
for (var i = 0; i < opcount; i++)
{
var v1 = Vec256.Load(lhsSrc.TakeSpan(len));
var v2 = Vec256.Load(rhsSrc.TakeSpan(len));
sw.Start();
dinx.mul(v1, v2);
sw.Stop();
}
Collect((opcount, snapshot(sw), "direct"));
sw.Reset();
for (var i = 0; i < opcount; i++)
{
var v1 = Vec256.Load(lhsSrc.TakeSpan(len));
var v2 = Vec256.Load(rhsSrc.TakeSpan(len));
sw.Start();
_mm256_mul_epi32(v1, v2);
sw.Stop();
}
Collect((opcount, snapshot(sw), "dsl"));
}
public static Span256 <float> sqrt(Span256 <float> src, Span256 <float> dst)
{
for (var block = 0; block < src.BlockCount; block++)
{
var x = Vec256.Load(ref src.Block(block));
vstore(dfp.sqrt(x), ref dst[block]);
}
return(dst);
}
/// <summary>
/// Creates a vector populated with component values that alternate between the first operand and the second
/// </summary>
/// <param name="a">The first operand</param>
/// <param name="b">The second operand</param>
/// <typeparam name="T">The primal component type</typeparam>
public static Vec256 <T> Alternate <T>(T a, T b)
where T : unmanaged
{
var n = Vec256 <T> .Length;
var dst = Span256.AllocBlock <T>();
for (var i = 0; i < n; i++)
{
dst[i] = even(i) ? a : b;
}
return(Vec256.Load(ref head(dst)));
}
static Vec256 <T> CalcUnits()
{
var n = Length;
var dst = Span256.Alloc <T>(n);
var one = gmath.one <T>();
for (var i = 0; i < n; i++)
{
dst[i] = one;
}
return(Vec256.Load(dst));
}
/// <summary>
/// Creates a vector with incrementing components
/// v[0] = first and v[i+1] = v[i] + 1 for i=1...N-1
/// </summary>
/// <param name="first">The value of the first component</param>
/// <typeparam name="T">The primal component type</typeparam>
public static Vec256 <T> Increments(T first = default, params Swap[] swaps)
{
var n = Length;
var dst = Span256.Alloc <T>(n);
var val = first;
for (var i = 0; i < n; i++)
{
dst[i] = val;
gmath.inc(ref val);
}
return(Vec256.Load(dst.Swap(swaps)));
}
void mul256f64_check(int cycles = DefaltCycleCount)
{
for (var cycle = 0; cycle < cycles; cycle++)
{
var domain = closed((long)Int32.MinValue, (long)Int32.MaxValue);
var src = Random.Stream(domain).Select(x => (double)x);
var u = Vec256.Load(src.TakeSpan(4));
var v = Vec256.Load(src.TakeSpan(4));
var x = dfp.fmul(u, v);
var y = Vec256.Load(mathspan.mul(u.ToSpan(), v.ToSpan(), v.ToSpan().Replicate(true)));
Claim.eq(x, y);
var xi = x.ToSpan().Convert <long>();
var yi = y.ToSpan().Convert <long>();
Claim.eq(xi, yi);
}
}
public static Vec256 <int> swap(Vec256 <int> src, byte i, byte j)
{
Span <int> control = stackalloc int[Vec256 <int> .Length];
for (byte k = 0; k < control.Length; k++)
{
if (k == i)
{
control[k] = j;
}
else if (k == j)
{
control[k] = i;
}
else
{
control[k] = k;
}
}
return(perm8x32(src, Vec256.Load(control)));
}
public static void VerifyUnaryOp <T>(IPolyrand random, int blocks, Vec256UnaryOp <T> inXOp, Func <T, T> primalOp)
where T : unmanaged
{
var blocklen = Span256 <T> .BlockLength;
var src = random.ReadOnlySpan256 <T>(blocks);
Claim.eq(blocks * blocklen, src.Length);
var expect = Span256.AllocBlocks <T>(blocks);
Claim.eq(blocks, expect.BlockCount);
var actual = Span256.AllocBlocks <T>(blocks);
Claim.eq(blocks, actual.BlockCount);
var tmp = new T[blocklen];
for (var block = 0; block < blocks; block++)
{
var offset = block * blocklen;
for (var i = 0; i < blocklen; i++)
{
tmp[i] = primalOp(src[offset + i]);
}
var vExpect = Vec256.Load <T>(ref tmp[0]);
var vX = src.LoadVec256(block);
var vActual = inXOp(vX);
Claim.eq(vExpect, vActual);
ginx.store(vExpect, ref expect.Block(block));
ginx.store(vActual, ref actual.Block(block));
}
Claim.eq(expect, actual);
}
public static Vec256 <T> LoadVec256 <T>(this ReadOnlySpan256 <T> src, int block = 0)
where T : unmanaged
=> Vec256.Load(src, block);
public static Vec256 <T> Replicate <T>(this Vec256 <T> src)
where T : unmanaged
=> Vec256.Load(src.ToSpan256());
