public static void CrossProduct3D_Theory(Vector256 <double> left, Vector256 <double> right, Vector256 <double> discard, Vector3d expected) { Vector256 <double> result = Vector.CrossProduct3D(left, right); Assert.True(TestHelpers.AreEqual(expected, result), $"Expected {expected}, got {result}"); }
private void ValidateResult(Vector256 <Int64> result, Int64 expectedValue, [CallerMemberName] string method = "") { Int64[] resultElements = new Int64[ElementCount]; Unsafe.WriteUnaligned(ref Unsafe.As <Int64, byte>(ref resultElements[0]), result); ValidateResult(resultElements, expectedValue, method); }
public static void Inequality_Theory(Vector256 <double> left, Vector256 <double> right, bool[] expected) { Vector256 <long> result = Vector.Inequality(left, right).AsInt64(); Assert.True((bool)AreAllNotEqual(expected, result)); }
private ColorPacket256 GetNaturalColor(Vector256 <int> things, VectorPacket256 pos, VectorPacket256 norms, VectorPacket256 rds, Scene scene) { var colors = ColorPacket256Helper.DefaultColor; for (int i = 0; i < scene.Lights.Length; i++) { var lights = scene.Lights[i]; var zero = SetZeroVector256 <float>(); var colorPacket = lights.Colors; var ldis = lights.Positions - pos; var livec = ldis.Normalize(); var neatIsectDis = TestRay(new RayPacket256(pos, livec), scene); // is in shadow? var mask1 = Compare(neatIsectDis, ldis.Lengths, FloatComparisonMode.LessThanOrEqualOrderedNonSignaling); var mask2 = Compare(neatIsectDis, zero, FloatComparisonMode.NotEqualOrderedNonSignaling); var isInShadow = And(mask1, mask2); Vector256 <float> illum = VectorPacket256.DotProduct(livec, norms); Vector256 <float> illumGraterThanZero = Compare(illum, zero, FloatComparisonMode.GreaterThanOrderedNonSignaling); var tmpColor1 = illum * colorPacket; var defaultRGB = zero; Vector256 <float> lcolorR = BlendVariable(defaultRGB, tmpColor1.Xs, illumGraterThanZero); Vector256 <float> lcolorG = BlendVariable(defaultRGB, tmpColor1.Ys, illumGraterThanZero); Vector256 <float> lcolorB = BlendVariable(defaultRGB, tmpColor1.Zs, illumGraterThanZero); ColorPacket256 lcolor = new ColorPacket256(lcolorR, lcolorG, lcolorB); Vector256 <float> specular = VectorPacket256.DotProduct(livec, rds.Normalize()); Vector256 <float> specularGraterThanZero = Compare(specular, zero, FloatComparisonMode.GreaterThanOrderedNonSignaling); var difColor = new ColorPacket256(1, 1, 1); var splColor = new ColorPacket256(1, 1, 1); var roughness = SetAllVector256 <float>(1); for (int j = 0; j < scene.Things.Length; j++) { Vector256 <float> thingMask = StaticCast <int, float>(CompareEqual(things, SetAllVector256 <int>(j))); var rgh = SetAllVector256 <float>(scene.Things[j].Surface.Roughness); var dif = scene.Things[j].Surface.Diffuse(pos); var spl = scene.Things[j].Surface.Specular; roughness = BlendVariable(roughness, rgh, thingMask); difColor.Xs = BlendVariable(difColor.Xs, dif.Xs, thingMask); difColor.Ys = BlendVariable(difColor.Ys, dif.Ys, thingMask); difColor.Zs = BlendVariable(difColor.Zs, dif.Zs, thingMask); splColor.Xs = BlendVariable(splColor.Xs, spl.Xs, thingMask); splColor.Ys = BlendVariable(splColor.Ys, spl.Ys, thingMask); splColor.Zs = BlendVariable(splColor.Zs, spl.Zs, thingMask); } var tmpColor2 = VectorMath.Pow(specular, roughness) * colorPacket; Vector256 <float> scolorR = BlendVariable(defaultRGB, tmpColor2.Xs, specularGraterThanZero); Vector256 <float> scolorG = BlendVariable(defaultRGB, tmpColor2.Ys, specularGraterThanZero); Vector256 <float> scolorB = BlendVariable(defaultRGB, tmpColor2.Zs, specularGraterThanZero); ColorPacket256 scolor = new ColorPacket256(scolorR, scolorG, scolorB); var oldColor = colors; colors = colors + ColorPacket256Helper.Times(difColor, lcolor) + ColorPacket256Helper.Times(splColor, scolor); colors = new ColorPacket256(BlendVariable(colors.Xs, oldColor.Xs, isInShadow), BlendVariable(colors.Ys, oldColor.Ys, isInShadow), BlendVariable(colors.Zs, oldColor.Zs, isInShadow)); } return(colors); }
public void RunReflectionScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario)); Vector256 <UInt32> value; value = Vector256.Create(TestLibrary.Generator.GetUInt32()); object byteResult = typeof(Vector256 <UInt32>) .GetMethod(nameof(Vector256 <UInt32> .AsByte), new Type[] { }) .Invoke(value, new object[] { }); ValidateResult((Vector256 <byte>)(byteResult), value); value = Vector256.Create(TestLibrary.Generator.GetUInt32()); object doubleResult = typeof(Vector256 <UInt32>) .GetMethod(nameof(Vector256 <UInt32> .AsDouble), new Type[] { }) .Invoke(value, new object[] { }); ValidateResult((Vector256 <double>)(doubleResult), value); value = Vector256.Create(TestLibrary.Generator.GetUInt32()); object shortResult = typeof(Vector256 <UInt32>) .GetMethod(nameof(Vector256 <UInt32> .AsInt16), new Type[] { }) .Invoke(value, new object[] { }); ValidateResult((Vector256 <short>)(shortResult), value); value = Vector256.Create(TestLibrary.Generator.GetUInt32()); object intResult = typeof(Vector256 <UInt32>) .GetMethod(nameof(Vector256 <UInt32> .AsInt32), new Type[] { }) .Invoke(value, new object[] { }); ValidateResult((Vector256 <int>)(intResult), value); value = Vector256.Create(TestLibrary.Generator.GetUInt32()); object longResult = typeof(Vector256 <UInt32>) .GetMethod(nameof(Vector256 <UInt32> .AsInt64), new Type[] { }) .Invoke(value, new object[] { }); ValidateResult((Vector256 <long>)(longResult), value); value = Vector256.Create(TestLibrary.Generator.GetUInt32()); object sbyteResult = typeof(Vector256 <UInt32>) .GetMethod(nameof(Vector256 <UInt32> .AsSByte), new Type[] { }) .Invoke(value, new object[] { }); ValidateResult((Vector256 <sbyte>)(sbyteResult), value); value = Vector256.Create(TestLibrary.Generator.GetUInt32()); object floatResult = typeof(Vector256 <UInt32>) .GetMethod(nameof(Vector256 <UInt32> .AsSingle), new Type[] { }) .Invoke(value, new object[] { }); ValidateResult((Vector256 <float>)(floatResult), value); value = Vector256.Create(TestLibrary.Generator.GetUInt32()); object ushortResult = typeof(Vector256 <UInt32>) .GetMethod(nameof(Vector256 <UInt32> .AsUInt16), new Type[] { }) .Invoke(value, new object[] { }); ValidateResult((Vector256 <ushort>)(ushortResult), value); value = Vector256.Create(TestLibrary.Generator.GetUInt32()); object uintResult = typeof(Vector256 <UInt32>) .GetMethod(nameof(Vector256 <UInt32> .AsUInt32), new Type[] { }) .Invoke(value, new object[] { }); ValidateResult((Vector256 <uint>)(uintResult), value); value = Vector256.Create(TestLibrary.Generator.GetUInt32()); object ulongResult = typeof(Vector256 <UInt32>) .GetMethod(nameof(Vector256 <UInt32> .AsUInt64), new Type[] { }) .Invoke(value, new object[] { }); ValidateResult((Vector256 <ulong>)(ulongResult), value); }
public static unsafe int Main() { init(); if (Sse2.IsSupported) { Vector128 <float> result_v128 = F2_v128(0.5F); Vector128 <float> expectedResult_v128 = F1_v128(0.5F); float *result = stackalloc float[4]; Sse.Store(result, result_v128); float *expResult = stackalloc float[4]; Sse.Store(expResult, expectedResult_v128); for (int i = 0; i < 4; i++) { if (result[i] != expResult[i]) { Console.WriteLine("Vector128<float> test FAILED"); Console.Write("[ "); for (int j = 0; j < 4; j++) { Console.Write(result[j] + ", "); } Console.WriteLine("]"); return(Fail); } } if (Vector128ReturnTest() != Pass) { Console.WriteLine("Vector128ReturnTest FAILED"); return(Fail); } Vector128 <short> result_v128i = F2_v128i(6); Vector128 <short> expectedResult_v128i = F1_v128i(6); short *results = stackalloc short[8]; Sse2.Store(results, result_v128i); short *expResults = stackalloc short[8]; Sse2.Store(expResults, expectedResult_v128i); for (int i = 0; i < 8; i++) { if (results[i] != expResults[i]) { Console.WriteLine("Vector128<short> test FAILED"); Console.Write("[ "); for (int j = 0; j < 8; j++) { Console.Write(results[j] + ", "); } Console.WriteLine("]"); return(Fail); } } if (Vector128Int16ReturnTest() != Pass) { Console.WriteLine("Vector128Int16ReturnTest FAILED"); return(Fail); } } if (Avx2.IsSupported) { Vector256 <float> result_v256 = F2_v256(0.7F); Vector256 <float> expectedResult_v256 = F1_v256(0.7F); float *result = stackalloc float[8]; Avx.Store(result, result_v256); float *expResult = stackalloc float[8]; Avx.Store(expResult, expectedResult_v256); for (int i = 0; i < 8; i++) { if (result[i] != expResult[i]) { Console.WriteLine("Vector256<float> test FAILED"); Console.Write("[ "); for (int j = 0; j < 8; j++) { Console.Write(result[j] + ", "); } Console.WriteLine("]"); return(Fail); } } if (Vector256ReturnTest() != Pass) { Console.WriteLine("Vector256ReturnTest FAILED"); return(Fail); } Vector256 <byte> result_v256i = F2_v256i(7); Vector256 <byte> expectedResult_v256i = F1_v256i(7); byte *resultb = stackalloc byte[32]; Avx.Store(resultb, result_v256i); byte *expResultb = stackalloc byte[32]; Avx.Store(expResultb, expectedResult_v256i); for (int i = 0; i < 32; i++) { if (resultb[i] != expResultb[i]) { Console.WriteLine("Vector256<byte> test FAILED"); Console.Write("[ "); for (int j = 0; j < 32; j++) { Console.Write(resultb[j] + ", "); } Console.WriteLine("]"); return(Fail); } } if (Vector256Int32ReturnTest() != Pass) { Console.WriteLine("Vector128Int16ReturnTest FAILED"); return(Fail); } } Console.WriteLine("PASSED"); return(Pass); }
public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException = false) { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario)); Double[] values = new Double[ElementCount]; for (int i = 0; i < ElementCount; i++) { values[i] = TestLibrary.Generator.GetDouble(); } Vector256 <Double> value = Vector256.Create(values[0], values[1], values[2], values[3]); bool succeeded = !expectedOutOfRangeException; try { object result = typeof(Vector256 <Double>) .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) }) .Invoke(value, new object[] { imm }); ValidateGetResult((Double)(result), values); } catch (TargetInvocationException e) { succeeded = expectedOutOfRangeException && e.InnerException is ArgumentOutOfRangeException; } if (!succeeded) { TestLibrary.TestFramework.LogInformation($"Vector256<Double.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException."); TestLibrary.TestFramework.LogInformation(string.Empty); Succeeded = false; } succeeded = !expectedOutOfRangeException; Double insertedValue = TestLibrary.Generator.GetDouble(); try { object result2 = typeof(Vector256 <Double>) .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Double) }) .Invoke(value, new object[] { imm, insertedValue }); ValidateWithResult((Vector256 <Double>)(result2), values, insertedValue); } catch (TargetInvocationException e) { succeeded = expectedOutOfRangeException && e.InnerException is ArgumentOutOfRangeException; } if (!succeeded) { TestLibrary.TestFramework.LogInformation($"Vector256<Double.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException."); TestLibrary.TestFramework.LogInformation(string.Empty); Succeeded = false; } }
public VectorArg256(Vector256 <float> _rgb) { this._rgb = _rgb; }
public VectorArg256 Change(float f) { Vector256 <float> t = Vector256.Create(f); return(new VectorArg256(Avx.Add(t, _rgb))); }
private void ValidateResult(Vector256 <UInt32> result, UInt32 expectedValue, [CallerMemberName] string method = "") { UInt32[] resultElements = new UInt32[ElementCount]; Unsafe.WriteUnaligned(ref Unsafe.As <UInt32, byte>(ref resultElements[0]), result); ValidateResult(resultElements, expectedValue, method); }
public unsafe int[,] IntegrateUnsafeVectorBranched() { int w = _data.Width(); int h = _data.Height(); int[,] res = new int[h, w]; Vector256 <int> shiftRight = RotateRight; fixed(byte *pSource = &_data[0, 0]) fixed(int *pTarget = &res[0, 0]) { var pSrc = pSource; var pTrg = pTarget; for (var i = 0; i < h; i++) { var j = 0; var p = Vector256.CreateScalar(0); var pr = Vector256.CreateScalar(0); //handle vector part for (; j + Vector256 <int> .Count <= w; j += Vector256 <int> .Count) { var t = Avx2.ConvertToVector256Int32(pSrc); //(int)*(pSrc) var s = Aggregate(p, t); // this code block has to be p = t; // added to handle the in-line t = Avx2.Add(t, s); // recursion: S[i]=a[i]+S[i-1] if (j > 0) { t = Avx2.Add(t, pr); // t += *(pTrg - 1); } if (i > 0) { t = Avx2.Add(t, Avx.LoadVector256(pTrg - w)); if (j > 0) { t = Avx2.Subtract(t, Avx.LoadVector256(pTrg - w - 8)); } } Avx.Store(pTrg, t); pr = t; pSrc += Vector256 <int> .Count; pTrg += Vector256 <int> .Count; } // handle the tail var pr2 = (j == 0 ? 0 : pr.GetElement(Vector256 <int> .Count - 1)); // Vector256.CreateScalar(0); for (; j < w; j++) { var t = (int)*(pSrc); // Avx2.ConvertToVector256Int32(pSrc); if (j > 0) { t += pr2; // t = Avx2.Add(t, pr); } if (i > 0) { t += *(pTrg - w); // Avx2.Add(t, Avx.LoadVector256(pTrg - w)); if (j > 0) { t -= *(pTrg - w - 1); // Avx2.Subtract(t, Avx.LoadVector256(pTrg - w - 8)); } } *pTrg = t; // Avx2.Store(pTrg, t); pr2 = t; // pr = t pSrc++; pTrg++; } } } return(res); }
public void Negate_Theory(Vector256 <double> vector, Vector4d expected) { Vector256 <double> result = Vector.Negate(vector); Assert.True(TestHelpers.AreEqual(expected, result), $"Expected {expected}, got {result}"); }
public void RunStructFldScenario(VectorBooleanBinaryOpTest__GreaterThanOrEqualAllUInt16 testClass) { var result = Vector256.GreaterThanOrEqualAll(_fld1, _fld2); testClass.ValidateResult(_fld1, _fld2, result); }
public Intersections(Vector256 <float> dis, Vector256 <int> things) { Distances = dis; ThingIndices = things; }
public static Vector256 <T> Vector256PlusOne <T>(Vector256 <T> v1) where T : struct { Vector256 <T> v2 = Vector256One <T>(); return(Vector256Add <T>(v1, v2)); }
private void ValidateResult(Vector256 <Single> firstOp, Vector256 <Single> secondOp, Vector256 <Single> thirdOp, void *result, [CallerMemberName] string method = "") { Single[] inArray1 = new Single[Op1ElementCount]; Single[] inArray2 = new Single[Op2ElementCount]; Single[] inArray3 = new Single[Op3ElementCount]; Single[] outArray = new Single[RetElementCount]; Unsafe.WriteUnaligned(ref Unsafe.As <Single, byte>(ref inArray1[0]), firstOp); Unsafe.WriteUnaligned(ref Unsafe.As <Single, byte>(ref inArray2[0]), secondOp); Unsafe.WriteUnaligned(ref Unsafe.As <Single, byte>(ref inArray3[0]), thirdOp); Unsafe.CopyBlockUnaligned(ref Unsafe.As <Single, byte>(ref outArray[0]), ref Unsafe.AsRef <byte>(result), (uint)Unsafe.SizeOf <Vector256 <Single> >()); ValidateResult(inArray1, inArray2, inArray3, outArray, method); }
public static Vector256 <int> GetVector256Int32PlusOne(Vector256 <int> v1) { Vector256 <int> v2 = GetVector256Int32One(); return(Avx2.Add(v1, v2)); }
return(new AvxVec3() { x = Avx.Add(x, other.x), y = Avx.Add(y, other.y), z = Avx.Add(z, other.z) });
private void ValidateWithResult(Vector256 <UInt16> result, UInt16[] values, UInt16 insertedValue, [CallerMemberName] string method = "") { UInt16[] resultElements = new UInt16[ElementCount]; Unsafe.WriteUnaligned(ref Unsafe.As <UInt16, byte>(ref resultElements[0]), result); ValidateWithResult(resultElements, values, insertedValue, method); }
public override void Step() { fixed(byte * currentFieldPtr = field, upperLineSumOf2Ptr = upperLineSumOf2, upperLineSumOf3Ptr = upperLineSumOf3, middleLineSumOf2Ptr = middleLineSumOf2, middleLineSumOf3Ptr = middleLineSumOf3, lowerLineSumOf2Ptr = lowerLineSumOf2, lowerLineSumOf3Ptr = lowerLineSumOf3) { byte *upper2 = upperLineSumOf2Ptr, upper3 = upperLineSumOf3Ptr; byte *middle2 = middleLineSumOf2Ptr, middle3 = middleLineSumOf3Ptr; byte *lower2 = lowerLineSumOf2Ptr, lower3 = lowerLineSumOf3Ptr; byte *nextLinePtr = currentFieldPtr + LINE_WIDTH; for (int x = 0; x < LINE_WIDTH; x += 32) { Avx2.Store(upper2 + x, Vector256 <byte> .Zero); Avx2.Store(upper3 + x, Vector256 <byte> .Zero); Avx2.Store(middle2 + x, Vector256 <byte> .Zero); Avx2.Store(middle3 + x, Vector256 <byte> .Zero); Vector256 <byte> nextLeft = Avx2.LoadVector256(nextLinePtr + x - 8); Vector256 <byte> nextCenter = Avx2.LoadVector256(nextLinePtr + x); Vector256 <byte> nextRight = Avx2.LoadVector256(nextLinePtr + x + 8); Vector256 <byte> lowerSum2 = Avx2.Add( Avx2.Add( Avx2.ShiftRightLogical(nextCenter.AsUInt64(), 4), Avx2.ShiftLeftLogical(nextCenter.AsUInt64(), 4)), Avx2.Add( Avx2.ShiftRightLogical(nextLeft.AsUInt64(), 60), Avx2.ShiftLeftLogical(nextRight.AsUInt64(), 60))).AsByte(); Avx2.Store(lower2 + x, lowerSum2); Vector256 <byte> lowerSum3 = Avx2.Add(lowerSum2, nextCenter); Avx2.Store(lower3 + x, lowerSum3); } for (int y = 1; y < HEIGHT - 1; y++) { nextLinePtr += LINE_WIDTH; byte *temp2 = upper2; byte *temp3 = upper3; upper2 = middle2; upper3 = middle3; middle2 = lower2; middle3 = lower3; lower2 = temp2; lower3 = temp3; for (int x = 0; x < LINE_WIDTH; x += 32) { Vector256 <byte> nextLeft = Avx2.LoadVector256(nextLinePtr + x - 8); Vector256 <byte> nextCenter = Avx2.LoadVector256(nextLinePtr + x); Vector256 <byte> nextRight = Avx2.LoadVector256(nextLinePtr + x + 8); Vector256 <byte> lowerSum2 = Avx2.Add( Avx2.Add( Avx2.ShiftRightLogical(nextCenter.AsUInt64(), 4), Avx2.ShiftLeftLogical(nextCenter.AsUInt64(), 4)), Avx2.Add( Avx2.ShiftRightLogical(nextLeft.AsUInt64(), 60), Avx2.ShiftLeftLogical(nextRight.AsUInt64(), 60))).AsByte(); Avx2.Store(lower2 + x, lowerSum2); Vector256 <byte> lowerSum3 = Avx2.Add(lowerSum2, nextCenter); Avx2.Store(lower2 + x, lowerSum2); Avx2.Store(lower3 + x, Avx2.Add(lowerSum2, nextCenter)); Vector256 <byte> neighbours = Avx2.Add( Avx2.LoadVector256(middle2 + x), Avx2.Add(Avx2.LoadVector256(upper3 + x), lowerSum3)); Vector256 <byte> alive = Avx2.LoadVector256(nextLinePtr - LINE_WIDTH + x); alive = Avx2.ShiftLeftLogical(alive.AsUInt64(), (byte)3).AsByte(); Vector256 <byte> mask = Avx2.Or(neighbours, alive); Vector256 <byte> mask_hi = Avx2.And(mask, v_hi); Vector256 <byte> mask_lo = Avx2.And(mask, v_lo); mask_hi = Avx2.ShiftRightLogical(mask_hi.AsUInt64(), 4).AsByte(); Vector256 <byte> shouldBeAlive_hi = Avx2.Shuffle(v_lookup, mask_hi); Vector256 <byte> shouldBeAlive_lo = Avx2.Shuffle(v_lookup, mask_lo); shouldBeAlive_hi = Avx2.ShiftLeftLogical(shouldBeAlive_hi.AsUInt64(), 4).AsByte(); Vector256 <byte> shouldBeAlive = Avx2.Or(shouldBeAlive_hi, shouldBeAlive_lo); Avx2.Store(nextLinePtr - LINE_WIDTH + x, shouldBeAlive); } *(byte *)(nextLinePtr - LINE_WIDTH) &= 0xF0; *(byte *)(nextLinePtr - 1) &= 0x0F; } } }
private void ValidateWithResult(Vector256 <Double> result, Double[] values, Double insertedValue, [CallerMemberName] string method = "") { Double[] resultElements = new Double[ElementCount]; Unsafe.WriteUnaligned(ref Unsafe.As <Double, byte>(ref resultElements[0]), result); ValidateWithResult(resultElements, values, insertedValue, method); }
public static Vector256 <double> CompareEqual_Software(Vector256 <double> left, Vector256 <double> right) { double lX = X(left), rX = X(right); double lY = Y(left), rY = Y(right); double lZ = Z(left), rZ = Z(right); double lW = W(left), rW = W(right); return(Vector256.Create( AsMaskDouble(lX == rX), AsMaskDouble(lY == rY), AsMaskDouble(lZ == rZ), AsMaskDouble(lW == rW) )); }
private ColorPacket256 GetReflectionColor(Vector256 <int> things, VectorPacket256 pos, VectorPacket256 norms, VectorPacket256 rds, Scene scene, int depth) { return(scene.Reflect(things, pos) * TraceRay(new RayPacket256(pos, rds), scene, depth + 1)); }
public static Vector256 <double> CompareGreaterThanOrEqual_Software(Vector256 <double> left, Vector256 <double> right) { double lX = X(left), rX = X(right); double lY = Y(left), rY = Y(right); double lZ = Z(left), rZ = Z(right); double lW = W(left), rW = W(right); return(Vector256.Create( AsMaskDouble(lX >= rX || IsNan(lX, rX)), AsMaskDouble(lY >= rY || IsNan(lY, rY)), AsMaskDouble(lZ >= rZ || IsNan(lZ, rZ)), AsMaskDouble(lW >= rW || IsNan(lW, rW)) )); }
public static Vector256 <float> Pow(Vector256 <float> left, Vector256 <float> right) { return(Exp(Multiply(right, Log(left)))); }
public static Vector256 <double> CompareLessThanOrEqual_Software(Vector256 <double> left, Vector256 <double> right) { double lX = X(left), rX = X(right); double lY = Y(left), rY = Y(right); double lZ = Z(left), rZ = Z(right); double lW = W(left), rW = W(right); return(Vector256.Create( AsMaskDouble(lX <= rX /* || IsNan(lX, rX)*/), AsMaskDouble(lY <= rY /* || IsNan(lY, rY)*/), AsMaskDouble(lZ <= rZ /* || IsNan(lZ, rZ)*/), AsMaskDouble(lW <= rW /* || IsNan(lW, rW)*/) )); }
private void ValidateResult(Vector256 <Double> result, Double expectedLowerValue, Double expectedUpperValue, [CallerMemberName] string method = "") { Double[] resultElements = new Double[ElementCount]; Unsafe.WriteUnaligned(ref Unsafe.As <Double, byte>(ref resultElements[0]), result); ValidateResult(resultElements, expectedLowerValue, expectedUpperValue, method); }
public static void GreaterThanOrEqualTo_Theory(Vector256 <double> left, Vector256 <double> right, bool[] expected) { Vector256 <long> result1 = Vector.GreaterThanOrEqual(left, right).AsInt64(); Assert.True((bool)AreAllEqual(expected, result1)); }
public static unsafe bool TryGetAsciiString(byte *input, char *output, int count) { Debug.Assert(input != null); Debug.Assert(output != null); var end = input + count; Debug.Assert((long)end >= Vector256 <sbyte> .Count); if (Sse2.IsSupported) { if (Avx2.IsSupported && input <= end - Vector256 <sbyte> .Count) { Vector256 <sbyte> zero = Vector256 <sbyte> .Zero; do { var vector = Avx.LoadVector256(input).AsSByte(); if (!CheckBytesInAsciiRange(vector, zero)) { return(false); } var tmp0 = Avx2.UnpackLow(vector, zero); var tmp1 = Avx2.UnpackHigh(vector, zero); // Bring into the right order var out0 = Avx2.Permute2x128(tmp0, tmp1, 0x20); var out1 = Avx2.Permute2x128(tmp0, tmp1, 0x31); Avx.Store((ushort *)output, out0.AsUInt16()); Avx.Store((ushort *)output + Vector256 <ushort> .Count, out1.AsUInt16()); input += Vector256 <sbyte> .Count; output += Vector256 <sbyte> .Count; } while (input <= end - Vector256 <sbyte> .Count); if (input == end) { return(true); } } if (input <= end - Vector128 <sbyte> .Count) { Vector128 <sbyte> zero = Vector128 <sbyte> .Zero; do { var vector = Sse2.LoadVector128(input).AsSByte(); if (!CheckBytesInAsciiRange(vector, zero)) { return(false); } var c0 = Sse2.UnpackLow(vector, zero).AsUInt16(); var c1 = Sse2.UnpackHigh(vector, zero).AsUInt16(); Sse2.Store((ushort *)output, c0); Sse2.Store((ushort *)output + Vector128 <ushort> .Count, c1); input += Vector128 <sbyte> .Count; output += Vector128 <sbyte> .Count; } while (input <= end - Vector128 <sbyte> .Count); if (input == end) { return(true); } } } else if (Vector.IsHardwareAccelerated) { while (input <= end - Vector <sbyte> .Count) { var vector = Unsafe.AsRef <Vector <sbyte> >(input); if (!CheckBytesInAsciiRange(vector)) { return(false); } Vector.Widen( vector, out Unsafe.AsRef <Vector <short> >(output), out Unsafe.AsRef <Vector <short> >(output + Vector <short> .Count)); input += Vector <sbyte> .Count; output += Vector <sbyte> .Count; } if (input == end) { return(true); } } if (Environment.Is64BitProcess) // Use Intrinsic switch for branch elimination { // 64-bit: Loop longs by default while (input <= end - sizeof(long)) { var value = *(long *)input; if (!CheckBytesInAsciiRange(value)) { return(false); } if (Bmi2.X64.IsSupported) { // BMI2 will work regardless of the processor's endianness. ((ulong *)output)[0] = Bmi2.X64.ParallelBitDeposit((ulong)value, 0x00FF00FF_00FF00FFul); ((ulong *)output)[1] = Bmi2.X64.ParallelBitDeposit((ulong)(value >> 32), 0x00FF00FF_00FF00FFul); } else { output[0] = (char)input[0]; output[1] = (char)input[1]; output[2] = (char)input[2]; output[3] = (char)input[3]; output[4] = (char)input[4]; output[5] = (char)input[5]; output[6] = (char)input[6]; output[7] = (char)input[7]; } input += sizeof(long); output += sizeof(long); } if (input <= end - sizeof(int)) { var value = *(int *)input; if (!CheckBytesInAsciiRange(value)) { return(false); } if (Bmi2.IsSupported) { // BMI2 will work regardless of the processor's endianness. ((uint *)output)[0] = Bmi2.ParallelBitDeposit((uint)value, 0x00FF00FFu); ((uint *)output)[1] = Bmi2.ParallelBitDeposit((uint)(value >> 16), 0x00FF00FFu); } else { output[0] = (char)input[0]; output[1] = (char)input[1]; output[2] = (char)input[2]; output[3] = (char)input[3]; } input += sizeof(int); output += sizeof(int); } } else { // 32-bit: Loop ints by default while (input <= end - sizeof(int)) { var value = *(int *)input; if (!CheckBytesInAsciiRange(value)) { return(false); } if (Bmi2.IsSupported) { // BMI2 will work regardless of the processor's endianness. ((uint *)output)[0] = Bmi2.ParallelBitDeposit((uint)value, 0x00FF00FFu); ((uint *)output)[1] = Bmi2.ParallelBitDeposit((uint)(value >> 16), 0x00FF00FFu); } else { output[0] = (char)input[0]; output[1] = (char)input[1]; output[2] = (char)input[2]; output[3] = (char)input[3]; } input += sizeof(int); output += sizeof(int); } } if (input <= end - sizeof(short)) { if (!CheckBytesInAsciiRange(((short *)input)[0])) { return(false); } output[0] = (char)input[0]; output[1] = (char)input[1]; input += sizeof(short); output += sizeof(short); } if (input < end) { if (!CheckBytesInAsciiRange(((sbyte *)input)[0])) { return(false); } output[0] = (char)input[0]; } return(true); }
public static IEnumerable <object[]> Data(VectorDimensions dimension) { var objs = new[] { new object[4] { Vector256.Create(0d), Vector256.Create(0d), Vector256.Create(0d), default(Vector4d) }, new object[4] { Vector256.Create(1d), Vector256.Create(1d), Vector256.Create(1d), default(Vector4d) }, new object[4] { Vector256.Create(-1d), Vector256.Create(-1d), Vector256.Create(-1d), default(Vector4d) }, new object[4] { Vector256.Create(-1d), Vector256.Create(1d, 4d, 9d, 16d), Vector256.Create(100d, 200d, 300d, 400d), default(Vector4d) }, new object[4] { Vector256.Create(1d, 2d, 3d, 4d), Vector256.Create(4d, -5d, 6d, 9d), Vector256.Create(0d), default(Vector4d) }, new object[4] { Vector256.Create(double.PositiveInfinity), Vector256.Create(double.PositiveInfinity), Vector256.Create(0d), default(Vector4d) }, new object[4] { Vector256.Create(double.PositiveInfinity), Vector256.Create(double.NegativeInfinity), Vector256.Create(0d), default(Vector4d) }, new object[4] { Vector256.Create(double.NaN), Vector256.Create(double.NegativeInfinity), Vector256.Create(double.PositiveInfinity), default(Vector4d) }, new object[4] { Vector256.Create(double.MaxValue, double.MinValue, double.NaN, 0), Vector256.Create(double.MaxValue, double.MinValue, double.NaN, 0), Vector256.Create(10d), default(Vector4d) }, }; foreach (object[] set in objs) { switch (dimension) { case VectorDimensions.V2D: { var v1 = (Vector256 <double>)set[0]; var v2 = (Vector256 <double>)set[1]; set[3] = TestHelpers.ByValToSlowVector2d(SoftwareFallbacks.CrossProduct2D_Software(v1, v2)); break; } case VectorDimensions.V3D: { var v1 = (Vector256 <double>)set[0]; var v2 = (Vector256 <double>)set[1]; set[3] = TestHelpers.ByValToSlowVector3d(SoftwareFallbacks.CrossProduct3D_Software(v1, v2)); break; } case VectorDimensions.V4D: { var v1 = (Vector256 <double>)set[0]; var v2 = (Vector256 <double>)set[1]; var v3 = (Vector256 <double>)set[2]; set[3] = TestHelpers.ByValToSlowVector4d(SoftwareFallbacks.CrossProduct4D_Software(v1, v2, v3)); break; } default: throw new ArgumentException(nameof(dimension)); } } return(objs); }