public static double sum(ReadOnlySpan <double> src)
{
var veclen = Vec128 <double> .Length;
var seglen = 2 * veclen;
var srclen = src.Length;
require(0 == srclen % seglen);
var dst = Vec128.Fill((double)0);
var offset = 0;
for (var i = 0; i < srclen; i += seglen)
{
var v1 = Vec128.Load(src, offset);
offset += veclen;
var v2 = Vec128.Load(src, offset);
offset += veclen;
var vSum = dfp.hadd(v1, v2);
dst = dfp.add(dst, vSum);
}
Span <double> final = stackalloc double[veclen];
vstore(dst, ref final[0]);
var total = (double)0;
for (var i = 0; i < veclen; i++)
{
total += final[i];
}
return(total);
}
static Vec128 <T> CalcUnits()
{
var n = Length;
var dst = Span128.Alloc <T>(n);
var one = gmath.one <T>();
for (var i = 0; i < n; i++)
{
dst[i] = one;
}
return(Vec128.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 Vec128 <T> Increments(T first = default, params Swap[] swaps)
{
var n = Length;
var dst = Span128.Alloc <T>(n);
var val = first;
for (var i = 0; i < n; i++)
{
dst[i] = val;
gmath.inc(ref val);
}
return(Vec128.Load(dst.Swap(swaps)));
}
public static void VerifyUnaryOp <T>(IPolyrand random, int blocks, Vec128UnaryOp <T> inXOp, Func <T, T> primalOp)
where T : unmanaged
{
var blocklen = Span128 <T> .BlockLength;
var src = random.ReadOnlySpan128 <T>(blocks);
Claim.eq(blocks * blocklen, src.Length);
var expect = Span128.AllocBlocks <T>(blocks);
Claim.eq(blocks, expect.BlockCount);
var actual = Span128.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 = Vec128.Load <T>(ref tmp[0]);
var vX = src.LoadVec128(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 Vec128 <T> LoadVec128 <T>(this Span <T> src, int offset = 0)
where T : unmanaged
=> Vec128.Load(ref src[offset]);
public static Vec128 <T> LoadVec128 <T>(this ReadOnlySpan128 <T> src, int block = 0)
where T : unmanaged
=> Vec128.Load(src, block);
public static Vec128 <T> Replicate <T>(this Vec128 <T> src)
where T : unmanaged
=> Vec128.Load(src.ToSpan128());
