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());