200if (Vector512.IsHardwareAccelerated && Avx512BW.IsSupported && source.Length >= Vector512<byte>.Count) 424Debug.Assert(source.Length >= Vector512<byte>.Count); 434Vector512<sbyte> weights = Vector512.Create( 445Vector512<uint> vs1 = Vector512.CreateScalar(s1); 446Vector512<uint> vs2 = Vector512.CreateScalar(s2); 447Vector512<uint> vs3 = Vector512<uint>.Zero; 451Vector512<byte> data = Vector512.LoadUnsafe(ref sourceRef); 454Vector512<uint> vs1_0 = vs1; 455vs1 += Avx512BW.SumAbsoluteDifferences(data, Vector512<byte>.Zero).AsUInt32(); 457vs2 += Avx512BW.MultiplyAddAdjacent(Avx512BW.MultiplyAddAdjacent(data, weights), Vector512<short>.One).AsUInt32();

20static abstract T Invoke(Vector512<T> x); 35public Vector512<T> Invoke(Vector512<T> x) => TOperator.Invoke(x); 72if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TTransformOperator.Vectorizable) 76if (remainder >= (uint)Vector512<T>.Count) 515Vector512<T> vresult = Vector512.Create(TAggregationOperator.IdentityValue); 519Vector512<T> beg = transform.Invoke(Vector512.LoadUnsafe(ref xRef)); 520Vector512<T> end = transform.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count)); 524if (remainder > (uint)(Vector512<T>.Count * 8)) 550misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)xPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T); 554Debug.Assert(((nuint)xPtr % (uint)sizeof(Vector512<T>)) == 0); 564misalignment = (uint)Vector512<T>.Count; 569Vector512<T> vector1; 570Vector512<T> vector2; 571Vector512<T> vector3; 572Vector512<T> vector4; 576while (remainder >= (uint)(Vector512<T>.Count * 8)) 580vector1 = transform.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0))); 581vector2 = transform.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1))); 582vector3 = transform.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2))); 583vector4 = transform.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3))); 592vector1 = transform.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4))); 593vector2 = transform.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5))); 594vector3 = transform.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6))); 595vector4 = transform.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7))); 605xPtr += (uint)(Vector512<T>.Count * 8); 607remainder -= (uint)(Vector512<T>.Count * 8); 628(nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector512<T>.Count); 636Vector512<T> vector = transform.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7))); 643Vector512<T> vector = transform.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6))); 650Vector512<T> vector = transform.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5))); 657Vector512<T> vector = transform.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4))); 664Vector512<T> vector = transform.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3))); 671Vector512<T> vector = transform.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2))); 678Vector512<T> vector = transform.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 1))); 1191if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TBinaryOperator.Vectorizable) 1195if (remainder >= (uint)Vector512<T>.Count) 1686Vector512<T> vresult = Vector512.Create(TAggregationOperator.IdentityValue); 1690Vector512<T> beg = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef), 1692Vector512<T> end = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count), 1693Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count)); 1697if (remainder > (uint)(Vector512<T>.Count * 8)) 1725misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)xPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T); 1730Debug.Assert(((nuint)xPtr % (uint)sizeof(Vector512<T>)) == 0); 1740misalignment = (uint)Vector512<T>.Count; 1748Vector512<T> vector1; 1749Vector512<T> vector2; 1750Vector512<T> vector3; 1751Vector512<T> vector4; 1755while (remainder >= (uint)(Vector512<T>.Count * 8)) 1759vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 1760Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0))); 1761vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 1762Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1))); 1763vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 1764Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2))); 1765vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 1766Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3))); 1775vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 1776Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4))); 1777vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 1778Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5))); 1779vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 1780Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6))); 1781vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 1782Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7))); 1792xPtr += (uint)(Vector512<T>.Count * 8); 1793yPtr += (uint)(Vector512<T>.Count * 8); 1795remainder -= (uint)(Vector512<T>.Count * 8); 1817(nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector512<T>.Count); 1825Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)), 1826Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 7))); 1833Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)), 1834Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 6))); 1841Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)), 1842Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 5))); 1849Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)), 1850Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 4))); 1857Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)), 1858Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 3))); 1865Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)), 1866Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 2))); 1873Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 1)), 1874Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 1))); 2463private static Vector512<T> CreateAlignmentMaskVector512<T>(int count) 2571private static Vector512<T> CreateRemainderMaskVector512<T>(int count)

20static abstract Vector512<T> Invoke(Vector512<T> x, Vector512<T> y); 85if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TBinaryOperator.Vectorizable) 87if (remainder >= (uint)Vector512<T>.Count) 644Vector512<T> beg = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef), 646Vector512<T> end = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count), 647Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count)); 649if (remainder > (uint)(Vector512<T>.Count * 8)) 676nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T); 682Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0); 687Vector512<T> vector1; 688Vector512<T> vector2; 689Vector512<T> vector3; 690Vector512<T> vector4; 697while (remainder >= (uint)(Vector512<T>.Count * 8)) 701vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 702Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0))); 703vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 704Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1))); 705vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 706Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2))); 707vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 708Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3))); 710vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 0)); 711vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 1)); 712vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 2)); 713vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 3)); 717vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 718Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4))); 719vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 720Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5))); 721vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 722Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6))); 723vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 724Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7))); 726vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 4)); 727vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 5)); 728vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 6)); 729vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 7)); 734xPtr += (uint)(Vector512<T>.Count * 8); 735yPtr += (uint)(Vector512<T>.Count * 8); 736dPtr += (uint)(Vector512<T>.Count * 8); 738remainder -= (uint)(Vector512<T>.Count * 8); 743while (remainder >= (uint)(Vector512<T>.Count * 8)) 747vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 748Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0))); 749vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 750Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1))); 751vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 752Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2))); 753vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 754Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3))); 756vector1.Store(dPtr + (uint)(Vector512<T>.Count * 0)); 757vector2.Store(dPtr + (uint)(Vector512<T>.Count * 1)); 758vector3.Store(dPtr + (uint)(Vector512<T>.Count * 2)); 759vector4.Store(dPtr + (uint)(Vector512<T>.Count * 3)); 763vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 764Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4))); 765vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 766Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5))); 767vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 768Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6))); 769vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 770Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7))); 772vector1.Store(dPtr + (uint)(Vector512<T>.Count * 4)); 773vector2.Store(dPtr + (uint)(Vector512<T>.Count * 5)); 774vector3.Store(dPtr + (uint)(Vector512<T>.Count * 6)); 775vector4.Store(dPtr + (uint)(Vector512<T>.Count * 7)); 780xPtr += (uint)(Vector512<T>.Count * 8); 781yPtr += (uint)(Vector512<T>.Count * 8); 782dPtr += (uint)(Vector512<T>.Count * 8); 784remainder -= (uint)(Vector512<T>.Count * 8); 804remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count); 806switch (remainder / (uint)Vector512<T>.Count) 810Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)), 811Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 8))); 812vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8)); 818Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)), 819Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 7))); 820vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7)); 826Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)), 827Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 6))); 828vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6)); 834Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)), 835Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 5))); 836vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5)); 842Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)), 843Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 4))); 844vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4)); 850Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)), 851Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 3))); 852vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3)); 858Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)), 859Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 2))); 860vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 2)); 867end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count); 1417if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TTransformOperator.Vectorizable && TBinaryOperator.Vectorizable) 1419if (remainder >= (uint)Vector512<T>.Count) 1968Vector512<T> yVec = Vector512.Create(y); 1970Vector512<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef)), 1972Vector512<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count)), 1975if (remainder > (uint)(Vector512<T>.Count * 8)) 2000nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T); 2005Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0); 2010Vector512<T> vector1; 2011Vector512<T> vector2; 2012Vector512<T> vector3; 2013Vector512<T> vector4; 2020while (remainder >= (uint)(Vector512<T>.Count * 8)) 2024vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0))), 2026vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1))), 2028vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2))), 2030vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3))), 2033vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 0)); 2034vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 1)); 2035vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 2)); 2036vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 3)); 2040vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4))), 2042vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5))), 2044vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6))), 2046vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7))), 2049vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 4)); 2050vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 5)); 2051vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 6)); 2052vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 7)); 2057xPtr += (uint)(Vector512<T>.Count * 8); 2058dPtr += (uint)(Vector512<T>.Count * 8); 2060remainder -= (uint)(Vector512<T>.Count * 8); 2065while (remainder >= (uint)(Vector512<T>.Count * 8)) 2069vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0))), 2071vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1))), 2073vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2))), 2075vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3))), 2078vector1.Store(dPtr + (uint)(Vector512<T>.Count * 0)); 2079vector2.Store(dPtr + (uint)(Vector512<T>.Count * 1)); 2080vector3.Store(dPtr + (uint)(Vector512<T>.Count * 2)); 2081vector4.Store(dPtr + (uint)(Vector512<T>.Count * 3)); 2085vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4))), 2087vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5))), 2089vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6))), 2091vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7))), 2094vector1.Store(dPtr + (uint)(Vector512<T>.Count * 4)); 2095vector2.Store(dPtr + (uint)(Vector512<T>.Count * 5)); 2096vector3.Store(dPtr + (uint)(Vector512<T>.Count * 6)); 2097vector4.Store(dPtr + (uint)(Vector512<T>.Count * 7)); 2102xPtr += (uint)(Vector512<T>.Count * 8); 2103dPtr += (uint)(Vector512<T>.Count * 8); 2105remainder -= (uint)(Vector512<T>.Count * 8); 2124remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count); 2126switch (remainder / (uint)Vector512<T>.Count) 2130Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8))), 2132vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8)); 2138Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7))), 2140vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7)); 2146Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6))), 2148vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6)); 2154Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5))), 2156vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5)); 2162Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4))), 2164vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4)); 2170Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3))), 2172vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3)); 2178Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2))), 2180vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 2)); 2187end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count); 2730private static T HorizontalAggregate<T, TAggregate>(Vector512<T> x) where TAggregate : struct, IBinaryOperator<T> => 2775public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => TOperator.Invoke(y, x);

21static abstract Vector512<T> Invoke(Vector512<T> x); 30static abstract bool ShouldEarlyExit(Vector512<T> result); 41public static bool ShouldEarlyExit(Vector512<T> result) => Vector512.AnyWhereAllBitsSet(result); 60public static bool ShouldEarlyExit(Vector512<T> result) => 61typeof(T) == typeof(float) ? Vector512.EqualsAny(result.AsUInt32(), Vector512<uint>.Zero) : 62typeof(T) == typeof(double) ? Vector512.EqualsAny(result.AsUInt64(), Vector512<ulong>.Zero) : 63Vector512.EqualsAny(result, Vector512<T>.Zero); 83if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 85oneVectorFromEnd = x.Length - Vector512<T>.Count; 96i += Vector512<T>.Count; 102TAnyAll.ShouldEarlyExit(TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count))))) 217if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 219int vectorFromEnd = x.Length - Vector512<T>.Count; 226i += Vector512<T>.Count; 233i = x.Length - Vector512<T>.Count; 241Vector512<byte> v = TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i)).AsByte(); 243(v & Vector512<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i); 325if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 327int vectorsFromEnd = x.Length - (Vector512<T>.Count * sizeof(T)); 334i += Vector512<T>.Count * sizeof(T); 341i = x.Length - (Vector512<T>.Count * sizeof(T)); 349Vector512<byte> v = 352TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<T>.Count))).AsUInt16()); 354(v & Vector512<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i); 442if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 444int vectorsFromEnd = x.Length - (Vector512<T>.Count * sizeof(T)); 451i += Vector512<T>.Count * sizeof(T); 458i = x.Length - (Vector512<T>.Count * sizeof(T)); 466Vector512<byte> v = 470TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<T>.Count))).AsUInt32()), 472TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (2 * Vector512<T>.Count)))).AsUInt32(), 473TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (3 * Vector512<T>.Count)))).AsUInt32())); 475(v & Vector512<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i); 569if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 573int vectorsFromEnd = x.Length - (Vector512<T>.Count * sizeof(T)); 580i += Vector512<T>.Count * sizeof(T); 587i = x.Length - (Vector512<T>.Count * sizeof(T)); 595Vector512<byte> v = 600TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<T>.Count))).AsUInt64()), 602TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (2 * Vector512<T>.Count)))).AsUInt64(), 603TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (3 * Vector512<T>.Count)))).AsUInt64())), 606TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (4 * Vector512<T>.Count)))).AsUInt64(), 607TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (5 * Vector512<T>.Count)))).AsUInt64()), 609TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (6 * Vector512<T>.Count)))).AsUInt64(), 610TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (7 * Vector512<T>.Count)))).AsUInt64()))); 612(v & Vector512<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i);

16static abstract T Aggregate(Vector512<T> value); 20static abstract Vector512<T> Compare(Vector512<T> x, Vector512<T> y); 31if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 555Vector512<T> result = Vector512.Create(x); 558Vector512<T> nanMask = Vector512.IsNaN(result); 559if (nanMask != Vector512<T>.Zero) 566Vector512<TInt> indexIncrement = Vector512.Create(TInt.CreateTruncating(Vector512<TInt>.Count)); 567Vector512<TInt> resultIndex = Vector512<TInt>.Indices; 568Vector512<TInt> currentIndex = resultIndex + indexIncrement; 569ReadOnlySpan<T> span = x.Slice(Vector512<T>.Count); 573Vector512<T> current; 574if (span.Length >= Vector512<T>.Count) 577span = span.Slice(Vector512<T>.Count); 582int start = x.Length - Vector512<T>.Count; 584currentIndex = Vector512.Create(TInt.CreateTruncating(start)) + Vector512<TInt>.Indices; 591Vector512<T> nanMask = Vector512.IsNaN(current); 592if (nanMask != Vector512<T>.Zero) 599Vector512<T> mask = TOperator.Compare(current, result); 610Vector512<TInt> aggMask = ~Vector512.Equals(result.As<T, TInt>(), Vector512.Create(aggResult).As<T, TInt>()); 611Vector512<TInt> aggIndex = resultIndex | aggMask; 622Vector512<T> result = Vector512.Create(x); 625Vector512<T> nanMask = Vector512.IsNaN(result); 626if (nanMask != Vector512<T>.Zero) 633Vector512<uint> indexIncrement = Vector512.Create((uint)Vector512<uint>.Count); 634Vector512<uint> resultIndex1 = Vector512<uint>.Indices; 635Vector512<uint> resultIndex2 = resultIndex1 + indexIncrement; 636Vector512<uint> currentIndex = resultIndex2 + indexIncrement; 637ReadOnlySpan<T> span = x.Slice(Vector512<T>.Count); 641Vector512<T> current; 642if (span.Length >= Vector512<T>.Count) 645span = span.Slice(Vector512<T>.Count); 650int start = x.Length - Vector512<T>.Count; 652currentIndex = Vector512.Create((uint)start) + Vector512<uint>.Indices; 659Vector512<T> nanMask = Vector512.IsNaN(current); 660if (nanMask != Vector512<T>.Zero) 667Vector512<T> mask = TOperator.Compare(current, result); 668(Vector512<int> mask1, Vector512<int> mask2) = Vector512.Widen(mask.AsInt16()); 681Vector512<short> aggMask = ~Vector512.Equals(result.AsInt16(), Vector512.Create(aggResult).AsInt16()); 683(Vector512<int> mask1, Vector512<int> mask2) = Vector512.Widen(aggMask); 684Vector512<uint> aggIndex = resultIndex1 | mask1.AsUInt32(); 697Vector512<T> result = Vector512.Create(x); 700Vector512<T> nanMask = Vector512.IsNaN(result); 701if (nanMask != Vector512<T>.Zero) 708Vector512<uint> indexIncrement = Vector512.Create((uint)Vector512<uint>.Count); 709Vector512<uint> resultIndex1 = Vector512<uint>.Indices; 710Vector512<uint> resultIndex2 = resultIndex1 + indexIncrement; 711Vector512<uint> resultIndex3 = resultIndex2 + indexIncrement; 712Vector512<uint> resultIndex4 = resultIndex3 + indexIncrement; 713Vector512<uint> currentIndex = resultIndex4 + indexIncrement; 714ReadOnlySpan<T> span = x.Slice(Vector512<T>.Count); 718Vector512<T> current; 719if (span.Length >= Vector512<T>.Count) 722span = span.Slice(Vector512<T>.Count); 727int start = x.Length - Vector512<T>.Count; 729currentIndex = Vector512.Create((uint)start) + Vector512<uint>.Indices; 736Vector512<T> nanMask = Vector512.IsNaN(current); 737if (nanMask != Vector512<T>.Zero) 744Vector512<T> mask = TOperator.Compare(current, result); 745(Vector512<short> lowerMask, Vector512<short> upperMask) = Vector512.Widen(mask.AsSByte()); 746(Vector512<int> mask1, Vector512<int> mask2) = Vector512.Widen(lowerMask); 747(Vector512<int> mask3, Vector512<int> mask4) = Vector512.Widen(upperMask); 764Vector512<sbyte> aggMask = ~Vector512.Equals(result.AsSByte(), Vector512.Create(aggResult).AsSByte()); 766(Vector512<short> lowerMask, Vector512<short> upperMask) = Vector512.Widen(aggMask); 767(Vector512<int> mask1, Vector512<int> mask2) = Vector512.Widen(lowerMask); 768(Vector512<int> mask3, Vector512<int> mask4) = Vector512.Widen(upperMask); 769Vector512<uint> aggIndex = resultIndex1 | mask1.AsUInt32();

20Vector512<T> Invoke(Vector512<T> x); 51if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TStatefulUnaryOperator.Vectorizable) 53if (remainder >= (uint)Vector512<T>.Count) 547Vector512<T> beg = op.Invoke(Vector512.LoadUnsafe(ref xRef)); 548Vector512<T> end = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count)); 550if (remainder > (uint)(Vector512<T>.Count * 8)) 575nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T); 580Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0); 585Vector512<T> vector1; 586Vector512<T> vector2; 587Vector512<T> vector3; 588Vector512<T> vector4; 595while (remainder >= (uint)(Vector512<T>.Count * 8)) 599vector1 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0))); 600vector2 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1))); 601vector3 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2))); 602vector4 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3))); 604vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 0)); 605vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 1)); 606vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 2)); 607vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 3)); 611vector1 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4))); 612vector2 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5))); 613vector3 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6))); 614vector4 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7))); 616vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 4)); 617vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 5)); 618vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 6)); 619vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 7)); 624xPtr += (uint)(Vector512<T>.Count * 8); 625dPtr += (uint)(Vector512<T>.Count * 8); 627remainder -= (uint)(Vector512<T>.Count * 8); 632while (remainder >= (uint)(Vector512<T>.Count * 8)) 636vector1 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0))); 637vector2 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1))); 638vector3 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2))); 639vector4 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3))); 641vector1.Store(dPtr + (uint)(Vector512<T>.Count * 0)); 642vector2.Store(dPtr + (uint)(Vector512<T>.Count * 1)); 643vector3.Store(dPtr + (uint)(Vector512<T>.Count * 2)); 644vector4.Store(dPtr + (uint)(Vector512<T>.Count * 3)); 648vector1 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4))); 649vector2 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5))); 650vector3 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6))); 651vector4 = op.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7))); 653vector1.Store(dPtr + (uint)(Vector512<T>.Count * 4)); 654vector2.Store(dPtr + (uint)(Vector512<T>.Count * 5)); 655vector3.Store(dPtr + (uint)(Vector512<T>.Count * 6)); 656vector4.Store(dPtr + (uint)(Vector512<T>.Count * 7)); 661xPtr += (uint)(Vector512<T>.Count * 8); 662dPtr += (uint)(Vector512<T>.Count * 8); 664remainder -= (uint)(Vector512<T>.Count * 8); 683remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count); 685switch (remainder / (uint)Vector512<T>.Count) 689Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8))); 690vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8)); 696Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7))); 697vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7)); 703Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6))); 704vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6)); 710Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5))); 711vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5)); 717Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4))); 718vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4)); 724Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3))); 725vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3)); 731Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2))); 732vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 2)); 739end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count);

20static abstract Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z); 30public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z) => TOperator.Invoke(x, z, y); 72if (TTernaryOperator.Vectorizable && Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported) 74if (remainder >= (uint)Vector512<T>.Count) 694Vector512<T> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef), 697Vector512<T> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count), 698Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count), 699Vector512.LoadUnsafe(ref zRef, remainder - (uint)Vector512<T>.Count)); 701if (remainder > (uint)(Vector512<T>.Count * 8)) 730nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T); 737Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0); 742Vector512<T> vector1; 743Vector512<T> vector2; 744Vector512<T> vector3; 745Vector512<T> vector4; 752while (remainder >= (uint)(Vector512<T>.Count * 8)) 756vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 757Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)), 758Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 0))); 759vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 760Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)), 761Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 1))); 762vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 763Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)), 764Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 2))); 765vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 766Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)), 767Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 3))); 769vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 0)); 770vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 1)); 771vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 2)); 772vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 3)); 776vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 777Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)), 778Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 4))); 779vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 780Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)), 781Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 5))); 782vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 783Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)), 784Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 6))); 785vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 786Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)), 787Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 7))); 789vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 4)); 790vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 5)); 791vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 6)); 792vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 7)); 797xPtr += (uint)(Vector512<T>.Count * 8); 798yPtr += (uint)(Vector512<T>.Count * 8); 799zPtr += (uint)(Vector512<T>.Count * 8); 800dPtr += (uint)(Vector512<T>.Count * 8); 802remainder -= (uint)(Vector512<T>.Count * 8); 807while (remainder >= (uint)(Vector512<T>.Count * 8)) 811vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 812Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)), 813Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 0))); 814vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 815Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)), 816Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 1))); 817vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 818Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)), 819Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 2))); 820vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 821Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)), 822Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 3))); 824vector1.Store(dPtr + (uint)(Vector512<T>.Count * 0)); 825vector2.Store(dPtr + (uint)(Vector512<T>.Count * 1)); 826vector3.Store(dPtr + (uint)(Vector512<T>.Count * 2)); 827vector4.Store(dPtr + (uint)(Vector512<T>.Count * 3)); 831vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 832Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)), 833Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 4))); 834vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 835Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)), 836Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 5))); 837vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 838Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)), 839Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 6))); 840vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 841Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)), 842Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 7))); 844vector1.Store(dPtr + (uint)(Vector512<T>.Count * 4)); 845vector2.Store(dPtr + (uint)(Vector512<T>.Count * 5)); 846vector3.Store(dPtr + (uint)(Vector512<T>.Count * 6)); 847vector4.Store(dPtr + (uint)(Vector512<T>.Count * 7)); 852xPtr += (uint)(Vector512<T>.Count * 8); 853yPtr += (uint)(Vector512<T>.Count * 8); 854zPtr += (uint)(Vector512<T>.Count * 8); 855dPtr += (uint)(Vector512<T>.Count * 8); 857remainder -= (uint)(Vector512<T>.Count * 8); 878remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count); 880switch (remainder / (uint)Vector512<T>.Count) 884Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)), 885Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 8)), 886Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 8))); 887vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8)); 893Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)), 894Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 7)), 895Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 7))); 896vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7)); 902Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)), 903Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 6)), 904Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 6))); 905vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6)); 911Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)), 912Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 5)), 913Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 5))); 914vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5)); 920Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)), 921Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 4)), 922Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 4))); 923vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4)); 929Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)), 930Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 3)), 931Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 3))); 932vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3)); 938Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)), 939Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 2)), 940Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 2))); 941vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 2)); 948end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count); 1547if (TTernaryOperator.Vectorizable && Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported) 1549if (remainder >= (uint)Vector512<T>.Count) 2161Vector512<T> zVec = Vector512.Create(z); 2163Vector512<T> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef), 2166Vector512<T> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count), 2167Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count), 2170if (remainder > (uint)(Vector512<T>.Count * 8)) 2197nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T); 2203Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0); 2208Vector512<T> vector1; 2209Vector512<T> vector2; 2210Vector512<T> vector3; 2211Vector512<T> vector4; 2218while (remainder >= (uint)(Vector512<T>.Count * 8)) 2222vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 2223Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)), 2225vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 2226Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)), 2228vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 2229Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)), 2231vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 2232Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)), 2235vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 0)); 2236vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 1)); 2237vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 2)); 2238vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 3)); 2242vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 2243Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)), 2245vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 2246Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)), 2248vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 2249Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)), 2251vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 2252Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)), 2255vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 4)); 2256vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 5)); 2257vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 6)); 2258vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 7)); 2263xPtr += (uint)(Vector512<T>.Count * 8); 2264yPtr += (uint)(Vector512<T>.Count * 8); 2265dPtr += (uint)(Vector512<T>.Count * 8); 2267remainder -= (uint)(Vector512<T>.Count * 8); 2272while (remainder >= (uint)(Vector512<T>.Count * 8)) 2276vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 2277Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)), 2279vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 2280Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)), 2282vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 2283Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)), 2285vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 2286Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)), 2289vector1.Store(dPtr + (uint)(Vector512<T>.Count * 0)); 2290vector2.Store(dPtr + (uint)(Vector512<T>.Count * 1)); 2291vector3.Store(dPtr + (uint)(Vector512<T>.Count * 2)); 2292vector4.Store(dPtr + (uint)(Vector512<T>.Count * 3)); 2296vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 2297Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)), 2299vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 2300Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)), 2302vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 2303Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)), 2305vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 2306Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)), 2309vector1.Store(dPtr + (uint)(Vector512<T>.Count * 4)); 2310vector2.Store(dPtr + (uint)(Vector512<T>.Count * 5)); 2311vector3.Store(dPtr + (uint)(Vector512<T>.Count * 6)); 2312vector4.Store(dPtr + (uint)(Vector512<T>.Count * 7)); 2317xPtr += (uint)(Vector512<T>.Count * 8); 2318yPtr += (uint)(Vector512<T>.Count * 8); 2319dPtr += (uint)(Vector512<T>.Count * 8); 2321remainder -= (uint)(Vector512<T>.Count * 8); 2341remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count); 2343switch (remainder / (uint)Vector512<T>.Count) 2347Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)), 2348Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 8)), 2350vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8)); 2356Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)), 2357Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 7)), 2359vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7)); 2365Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)), 2366Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 6)), 2368vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6)); 2374Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)), 2375Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 5)), 2377vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5)); 2383Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)), 2384Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 4)), 2386vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4)); 2392Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)), 2393Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 3)), 2395vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3)); 2401Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)), 2402Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 2)), 2404vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 2)); 2411end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count); 3033if (TTernaryOperator.Vectorizable && Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported) 3035if (remainder >= (uint)Vector512<T>.Count) 3637Vector512<T> yVec = Vector512.Create(y); 3638Vector512<T> zVec = Vector512.Create(z); 3640Vector512<T> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef), 3643Vector512<T> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count), 3647if (remainder > (uint)(Vector512<T>.Count * 8)) 3672nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T); 3677Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0); 3682Vector512<T> vector1; 3683Vector512<T> vector2; 3684Vector512<T> vector3; 3685Vector512<T> vector4; 3692while (remainder >= (uint)(Vector512<T>.Count * 8)) 3696vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 3699vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 3702vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 3705vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 3709vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 0)); 3710vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 1)); 3711vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 2)); 3712vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 3)); 3716vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 3719vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 3722vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 3725vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 3729vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 4)); 3730vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 5)); 3731vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 6)); 3732vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 7)); 3737xPtr += (uint)(Vector512<T>.Count * 8); 3738dPtr += (uint)(Vector512<T>.Count * 8); 3740remainder -= (uint)(Vector512<T>.Count * 8); 3745while (remainder >= (uint)(Vector512<T>.Count * 8)) 3749vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 3752vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 3755vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 3758vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 3762vector1.Store(dPtr + (uint)(Vector512<T>.Count * 0)); 3763vector2.Store(dPtr + (uint)(Vector512<T>.Count * 1)); 3764vector3.Store(dPtr + (uint)(Vector512<T>.Count * 2)); 3765vector4.Store(dPtr + (uint)(Vector512<T>.Count * 3)); 3769vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 3772vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 3775vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 3778vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 3782vector1.Store(dPtr + (uint)(Vector512<T>.Count * 4)); 3783vector2.Store(dPtr + (uint)(Vector512<T>.Count * 5)); 3784vector3.Store(dPtr + (uint)(Vector512<T>.Count * 6)); 3785vector4.Store(dPtr + (uint)(Vector512<T>.Count * 7)); 3790xPtr += (uint)(Vector512<T>.Count * 8); 3791dPtr += (uint)(Vector512<T>.Count * 8); 3793remainder -= (uint)(Vector512<T>.Count * 8); 3812remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count); 3814switch (remainder / (uint)Vector512<T>.Count) 3818Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)), 3821vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8)); 3827Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)), 3830vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7)); 3836Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)), 3839vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6)); 3845Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)), 3848vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5)); 3854Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)), 3857vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4)); 3863Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)), 3866vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3)); 3872Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)), 3875vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 2)); 3882end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count);

19static abstract (Vector512<T> First, Vector512<T> Second) Invoke(Vector512<T> x); 29static abstract (Vector512<T> First, Vector512<T> Second) Invoke(Vector512<T> x, Vector512<T> y); 40public static (Vector512<T> First, Vector512<T> Second) Invoke(Vector512<T> x, Vector512<T> y) => TOperator.Invoke(y, x); 70if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TUnaryOperator.Vectorizable) 72oneVectorFromEnd = x.Length - Vector512<T>.Count; 78(Vector512<T> first, Vector512<T> second) = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i)); 82i += Vector512<T>.Count; 89i = x.Length - Vector512<T>.Count; 91(Vector512<T> first, Vector512<T> second) = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i)); 205if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TOperator.Vectorizable) 207oneVectorFromEnd = x.Length - Vector512<T>.Count; 213(Vector512<T> first, Vector512<T> second) = TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i), Vector512.LoadUnsafe(ref yRef, (uint)i)); 217i += Vector512<T>.Count; 224Vector512<T> mask = Vector512.Equals(CreateRemainderMaskVector512<T>(x.Length - i), Vector512<T>.Zero); 226i = x.Length - Vector512<T>.Count; 228Vector512<T> first = Vector512.ConditionalSelect(mask, 232Vector512<T> second = Vector512.ConditionalSelect(mask, 386if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TOperator.Vectorizable) 388oneVectorFromEnd = x.Length - Vector512<T>.Count; 391Vector512<T> yVec = Vector512.Create(y); 396(Vector512<T> first, Vector512<T> second) = TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i), yVec); 400i += Vector512<T>.Count; 407Vector512<T> mask = Vector512.Equals(CreateRemainderMaskVector512<T>(x.Length - i), Vector512<T>.Zero); 409i = x.Length - Vector512<T>.Count; 411Vector512<T> first = Vector512.ConditionalSelect(mask, 415Vector512<T> second = Vector512.ConditionalSelect(mask,

21static abstract (Vector512<TOutput>, Vector512<TOutput>, Vector512<TOutput>, Vector512<TOutput>) Invoke(Vector512<TInput> x); 46Debug.Assert(Vector512<TInput>.IsSupported); 47Debug.Assert(Vector512<TOutput>.IsSupported); 49oneVectorFromEnd = x.Length - Vector512<TInput>.Count; 55(Vector512<TOutput>, Vector512<TOutput>, Vector512<TOutput>, Vector512<TOutput>) results = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i)); 57results.Item2.StoreUnsafe(ref destinationRef, (uint)(i + Vector512<TOutput>.Count)); 58results.Item3.StoreUnsafe(ref destinationRef, (uint)(i + (Vector512<TOutput>.Count * 2))); 59results.Item4.StoreUnsafe(ref destinationRef, (uint)(i + (Vector512<TOutput>.Count * 3))); 61i += Vector512<TInput>.Count; 68i = x.Length - Vector512<TInput>.Count; 70(Vector512<TOutput>, Vector512<TOutput>, Vector512<TOutput>, Vector512<TOutput>) results = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i)); 72results.Item2.StoreUnsafe(ref destinationRef, (uint)(i + Vector512<TOutput>.Count)); 73results.Item3.StoreUnsafe(ref destinationRef, (uint)(i + (Vector512<TOutput>.Count * 2))); 74results.Item4.StoreUnsafe(ref destinationRef, (uint)(i + (Vector512<TOutput>.Count * 3)));

21static abstract (Vector512<TOutput> Lower, Vector512<TOutput> Upper) Invoke(Vector512<TInput> x); 46Debug.Assert(Vector512<TInput>.IsSupported); 47Debug.Assert(Vector512<TOutput>.IsSupported); 49oneVectorFromEnd = x.Length - Vector512<TInput>.Count; 55(Vector512<TOutput> lower, Vector512<TOutput> upper) = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i)); 57upper.StoreUnsafe(ref destinationRef, (uint)(i + Vector512<TOutput>.Count)); 59i += Vector512<TInput>.Count; 66i = x.Length - Vector512<TInput>.Count; 68(Vector512<TOutput> lower, Vector512<TOutput> upper) = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i)); 70upper.StoreUnsafe(ref destinationRef, (uint)(i + Vector512<TOutput>.Count));

37static abstract Vector512<TOutput> Invoke(Vector512<TInput> x); 47public static Vector512<T> Invoke(Vector512<T> x) => x; 91if (Vector512.IsHardwareAccelerated && Vector512<TInput>.IsSupported && Vector512<TOutput>.IsSupported && TUnaryOperator.Vectorizable && sizeof(TInput) == sizeof(TOutput)) 93if (remainder >= (uint)Vector512<TInput>.Count) 587Vector512<TOutput> beg = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef)); 588Vector512<TOutput> end = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<TInput>.Count)); 590if (remainder > (uint)(Vector512<TInput>.Count * 8)) 615nuint misalignment = ((uint)sizeof(Vector512<TInput>) - ((nuint)dPtr % (uint)sizeof(Vector512<TInput>))) / (uint)sizeof(TInput); 620Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<TInput>)) == 0); 625Vector512<TOutput> vector1; 626Vector512<TOutput> vector2; 627Vector512<TOutput> vector3; 628Vector512<TOutput> vector4; 635while (remainder >= (uint)(Vector512<TInput>.Count * 8)) 639vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 0))); 640vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 1))); 641vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 2))); 642vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 3))); 644vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 0)); 645vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 1)); 646vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 2)); 647vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 3)); 651vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 4))); 652vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 5))); 653vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 6))); 654vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 7))); 656vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 4)); 657vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 5)); 658vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 6)); 659vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 7)); 664xPtr += (uint)(Vector512<TInput>.Count * 8); 665dPtr += (uint)(Vector512<TInput>.Count * 8); 667remainder -= (uint)(Vector512<TInput>.Count * 8); 672while (remainder >= (uint)(Vector512<TInput>.Count * 8)) 676vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 0))); 677vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 1))); 678vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 2))); 679vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 3))); 681vector1.Store(dPtr + (uint)(Vector512<TOutput>.Count * 0)); 682vector2.Store(dPtr + (uint)(Vector512<TOutput>.Count * 1)); 683vector3.Store(dPtr + (uint)(Vector512<TOutput>.Count * 2)); 684vector4.Store(dPtr + (uint)(Vector512<TOutput>.Count * 3)); 688vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 4))); 689vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 5))); 690vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 6))); 691vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 7))); 693vector1.Store(dPtr + (uint)(Vector512<TOutput>.Count * 4)); 694vector2.Store(dPtr + (uint)(Vector512<TOutput>.Count * 5)); 695vector3.Store(dPtr + (uint)(Vector512<TOutput>.Count * 6)); 696vector4.Store(dPtr + (uint)(Vector512<TOutput>.Count * 7)); 701xPtr += (uint)(Vector512<TInput>.Count * 8); 702dPtr += (uint)(Vector512<TOutput>.Count * 8); 704remainder -= (uint)(Vector512<TInput>.Count * 8); 723remainder = (remainder + (uint)(Vector512<TInput>.Count - 1)) & (nuint)(-Vector512<TInput>.Count); 725switch (remainder / (uint)Vector512<TInput>.Count) 729Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 8))); 730vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 8)); 736Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 7))); 737vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 7)); 743Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 6))); 744vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 6)); 750Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 5))); 751vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 5)); 757Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 4))); 758vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 4)); 764Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 3))); 765vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 3)); 771Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 2))); 772vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 2)); 779end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<TOutput>.Count);

21static abstract Vector512<TOutput> Invoke(Vector512<TInput> lower, Vector512<TInput> upper); 46Debug.Assert(Vector512<TInput>.IsSupported); 47Debug.Assert(Vector512<TOutput>.IsSupported); 49twoVectorsFromEnd = x.Length - (Vector512<TInput>.Count * 2); 57Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i); 59i += Vector512<TInput>.Count * 2; 66i = x.Length - (Vector512<TInput>.Count * 2); 70Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i);

92public static Vector512<T> Invoke(Vector512<T> x) 103Vector512<T> abs = Vector512.ConditionalSelect(Vector512.LessThan(x, Vector512<T>.Zero), -x, x); 104if (Vector512.LessThan(abs, Vector512<T>.Zero) != Vector512<T>.Zero)

36public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();

36public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();

36public static Vector512<T> Invoke(Vector512<T> x) => AcosOperator<T>.Invoke(x) / Vector512.Create(T.Pi);

70public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x + y; 74public static T Invoke(Vector512<T> x) => Vector512.Sum(x);

102public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z) => (x + y) * z;

76public static Vector512<T> Invoke(Vector512<T> x)

36public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();

36public static Vector512<T> Invoke(Vector512<T> x) => AsinOperator<T>.Invoke(x) / Vector512.Create(T.Pi);

36public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();

77public static Vector512<T> Invoke(Vector512<T> y, Vector512<T> x) => throw new NotSupportedException();

77public static Vector512<T> Invoke(Vector512<T> y, Vector512<T> x) => Atan2Operator<T>.Invoke(y, x) / Vector512.Create(T.Pi);

36public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();

36public static Vector512<T> Invoke(Vector512<T> x) => AtanOperator<T>.Invoke(x) / Vector512.Create(T.Pi);

144public static Vector512<T> Invoke(Vector512<T> x) 148Vector512<float> xFloat = x.AsSingle(); 149Vector512<uint> bits = xFloat.AsUInt32(); 152Vector512<uint> result = Vector512.ConditionalSelect( 154bits + Vector512<uint>.One, 155bits - Vector512<uint>.One); 158Vector512<uint> isPositiveZero = Vector512.IsZero(xFloat).AsUInt32(); 159Vector512<uint> specialValue = Vector512.Create(BitConverter.SingleToUInt32Bits(-float.Epsilon)) & isPositiveZero; 161Vector512<uint> isNaNOrNegInf = (Vector512.IsNaN(xFloat) | Vector512.IsNegativeInfinity(xFloat)).AsUInt32(); 164Vector512<uint> specialMask = isPositiveZero | isNaNOrNegInf; 170Vector512<double> xDouble = x.AsDouble(); 171Vector512<ulong> bits = xDouble.AsUInt64(); 174Vector512<ulong> result = Vector512.ConditionalSelect( 176bits + Vector512<ulong>.One, 177bits - Vector512<ulong>.One); 180Vector512<ulong> isPositiveZero = Vector512.IsZero(xDouble).AsUInt64(); 181Vector512<ulong> specialValue = Vector512.Create(BitConverter.DoubleToUInt64Bits(-double.Epsilon)) & isPositiveZero; 183Vector512<ulong> isNaNOrNegInf = (Vector512.IsNaN(xDouble) | Vector512.IsNegativeInfinity(xDouble)).AsUInt64(); 186Vector512<ulong> specialMask = isPositiveZero | isNaNOrNegInf; 264public static Vector512<short> Invoke(Vector512<short> x) 266Vector512<ushort> bits = x.AsUInt16(); 269Vector512<ushort> isNegative = Vector512.IsNegative(x).AsUInt16(); 270Vector512<ushort> result = Vector512.ConditionalSelect( 272bits + Vector512<ushort>.One, 273bits - Vector512<ushort>.One); 276Vector512<ushort> isPositiveZero = Vector512.IsZero(bits); 277Vector512<ushort> specialValue = Vector512.Create(NegativeEpsilonBits) & isPositiveZero; 281Vector512<ushort> absValue = bits & Vector512.Create((ushort)0x7FFF); 282Vector512<ushort> isNaN = Vector512.GreaterThan(absValue, Vector512.Create(PositiveInfinityBits)); 283Vector512<ushort> isNegInf = Vector512.Equals(bits, Vector512.Create(NegativeInfinityBits)); 284Vector512<ushort> isNaNOrNegInf = isNaN | isNegInf; 287Vector512<ushort> specialMask = isPositiveZero | isNaNOrNegInf;

144public static Vector512<T> Invoke(Vector512<T> x) 148Vector512<float> xFloat = x.AsSingle(); 149Vector512<uint> bits = xFloat.AsUInt32(); 152Vector512<uint> result = Vector512.ConditionalSelect( 154bits - Vector512<uint>.One, 155bits + Vector512<uint>.One); 158Vector512<uint> isNegativeZero = Vector512.Equals(bits, Vector512.Create(0x8000_0000u)); 159Vector512<uint> specialValue = Vector512.Create(0x0000_0001u) & isNegativeZero; 161Vector512<uint> isNaNOrPosInf = (Vector512.IsNaN(xFloat) | Vector512.IsPositiveInfinity(xFloat)).AsUInt32(); 164Vector512<uint> specialMask = isNegativeZero | isNaNOrPosInf; 170Vector512<double> xDouble = x.AsDouble(); 171Vector512<ulong> bits = xDouble.AsUInt64(); 174Vector512<ulong> result = Vector512.ConditionalSelect( 176bits - Vector512<ulong>.One, 177bits + Vector512<ulong>.One); 180Vector512<ulong> isNegativeZero = Vector512.Equals(bits, Vector512.Create(0x8000_0000_0000_0000ul)); 181Vector512<ulong> specialValue = Vector512.Create(0x0000_0000_0000_0001ul) & isNegativeZero; 183Vector512<ulong> isNaNOrPosInf = (Vector512.IsNaN(xDouble) | Vector512.IsPositiveInfinity(xDouble)).AsUInt64(); 186Vector512<ulong> specialMask = isNegativeZero | isNaNOrPosInf; 264public static Vector512<short> Invoke(Vector512<short> x) 266Vector512<ushort> bits = x.AsUInt16(); 269Vector512<ushort> isNegative = Vector512.IsNegative(x).AsUInt16(); 270Vector512<ushort> result = Vector512.ConditionalSelect( 272bits - Vector512<ushort>.One, 273bits + Vector512<ushort>.One); 276Vector512<ushort> isNegativeZero = Vector512.Equals(bits, Vector512.Create(NegativeZeroBits)); 277Vector512<ushort> specialValue = Vector512.Create(EpsilonBits) & isNegativeZero; 281Vector512<ushort> absValue = bits & Vector512.Create((ushort)0x7FFF); 282Vector512<ushort> isNaN = Vector512.GreaterThan(absValue, Vector512.Create(PositiveInfinityBits)); 283Vector512<ushort> isPosInf = Vector512.Equals(bits, Vector512.Create(PositiveInfinityBits)); 284Vector512<ushort> isNaNOrPosInf = isNaN | isPosInf; 287Vector512<ushort> specialMask = isNegativeZero | isNaNOrPosInf;

63public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x & y;

63public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x | y;

59public static Vector512<T> Invoke(Vector512<T> x)

64public static Vector512<T> Invoke(Vector512<T> x)

224public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> min, Vector512<T> max) => Vector512.Clamp(x, min, max); 237public static Vector512<T> Invoke(Vector512<T> min, Vector512<T> max, Vector512<T> x) => Vector512.Clamp(x, min, max); 250public static Vector512<T> Invoke(Vector512<T> max, Vector512<T> x, Vector512<T> min) => Vector512.Clamp(x, min, max);

40public static Vector512<TTo> Invoke(Vector512<TFrom> x) => throw new NotSupportedException();

170public static Vector512<float> Invoke(Vector512<int> x) => Vector512.ConvertToSingle(x); 181public static Vector512<float> Invoke(Vector512<uint> x) => Vector512.ConvertToSingle(x); 192public static Vector512<double> Invoke(Vector512<ulong> x) => Vector512.ConvertToDouble(x); 203public static Vector512<double> Invoke(Vector512<long> x) => Vector512.ConvertToDouble(x); 214public static (Vector512<double> Lower, Vector512<double> Upper) Invoke(Vector512<float> x) => Vector512.Widen(x); 225public static Vector512<float> Invoke(Vector512<double> lower, Vector512<double> upper) => Vector512.Narrow(lower, upper); 236public static (Vector512<ushort> Lower, Vector512<ushort> Upper) Invoke(Vector512<byte> x) => Vector512.Widen(x); 265public static (Vector512<uint>, Vector512<uint>, Vector512<uint>, Vector512<uint>) Invoke(Vector512<byte> x) 267(Vector512<ushort> Lower, Vector512<ushort> Upper) ushorts = Vector512.Widen(x); 268(Vector512<uint> Lower, Vector512<uint> Upper) uintsLower = Vector512.Widen(ushorts.Lower); 269(Vector512<uint> Lower, Vector512<uint> Upper) uintsUpper = Vector512.Widen(ushorts.Upper); 306public static (Vector512<float>, Vector512<float>, Vector512<float>, Vector512<float>) Invoke(Vector512<byte> x) 326public static (Vector512<short> Lower, Vector512<short> Upper) Invoke(Vector512<sbyte> x) => Vector512.Widen(x); 337public static (Vector512<uint> Lower, Vector512<uint> Upper) Invoke(Vector512<ushort> x) => Vector512.Widen(x); 348public static (Vector512<int> Lower, Vector512<int> Upper) Invoke(Vector512<short> x) => Vector512.Widen(x); 359public static (Vector512<ulong> Lower, Vector512<ulong> Upper) Invoke(Vector512<uint> x) => Vector512.Widen(x); 370public static (Vector512<long> Lower, Vector512<long> Upper) Invoke(Vector512<int> x) => Vector512.Widen(x); 496public static (Vector512<float> Lower, Vector512<float> Upper) Invoke(Vector512<short> x) 498(Vector512<int> lowerInt32, Vector512<int> upperInt32) = Vector512.Widen(x); 503static Vector512<float> HalfAsWidenedUInt32ToSingle(Vector512<uint> value) 506Vector512<uint> sign = value & Vector512.Create(SingleSignMask); 509Vector512<uint> bitValueInProcess = value; 512Vector512<uint> offsetExponent = bitValueInProcess & Vector512.Create(HalfExponentMask); 515Vector512<uint> subnormalMask = Vector512.Equals(offsetExponent, Vector512<uint>.Zero); 518Vector512<uint> infinityOrNaNMask = Vector512.Equals(offsetExponent, Vector512.Create(HalfExponentMask)); 521Vector512<uint> maskedExponentLowerBound = subnormalMask & Vector512.Create(ExponentLowerBound); 524Vector512<uint> offsetMaskedExponentLowerBound = Vector512.Create(ExponentOffset) | maskedExponentLowerBound; 530offsetMaskedExponentLowerBound = Vector512.ConditionalSelect(Vector512.Equals(infinityOrNaNMask, Vector512<uint>.Zero), 541Vector512<uint> absoluteValue = (bitValueInProcess.AsSingle() - maskedExponentLowerBound.AsSingle()).AsUInt32(); 701public static Vector512<ushort> Invoke(Vector512<float> lower, Vector512<float> upper) 707static Vector512<uint> SingleToHalfAsWidenedUInt32(Vector512<float> value) 709Vector512<uint> bitValue = value.AsUInt32(); 712Vector512<uint> sign = Vector512.ShiftRightLogical(bitValue & Vector512.Create(SingleSignMask), 16); 715Vector512<uint> realMask = Vector512.Equals(value, value).AsUInt32(); 724Vector512<uint> exponentOffset0 = Vector512.Max(value, Vector512.Create(MinExp).AsSingle()).AsUInt32(); 737Vector512<uint> maskedHalfExponentForNaN = ~realMask & Vector512.Create(ExponentMask); 743Vector512<uint> newExponent = Vector512.ShiftRightLogical(bitValue, 13); 755Vector512<uint> signAndMaskedExponent = maskedHalfExponentForNaN | sign;

40public static Vector512<TTo> Invoke(Vector512<TFrom> x) => throw new NotSupportedException();

76public static Vector512<TTo> Invoke(Vector512<TFrom> x) 80return Vector512.IsNegative(Vector512<TTo>.AllBitsSet) != Vector512<TTo>.Zero ? 87return Vector512.IsNegative(Vector512<TTo>.AllBitsSet) != Vector512<TTo>.Zero ?

75public static Vector512<TTo> Invoke(Vector512<TFrom> x) 79return Vector512.IsNegative(Vector512<TTo>.AllBitsSet) != Vector512<TTo>.Zero ? 86return Vector512.IsNegative(Vector512<TTo>.AllBitsSet) != Vector512<TTo>.Zero ?

112public static Vector512<int> Invoke(Vector512<float> x) => Vector512.ConvertToInt32(x); 124public static Vector512<uint> Invoke(Vector512<float> x) => Vector512.ConvertToUInt32(x); 136public static Vector512<ulong> Invoke(Vector512<double> x) => Vector512.ConvertToUInt64(x); 148public static Vector512<long> Invoke(Vector512<double> x) => Vector512.ConvertToInt64(x); 159public static Vector512<byte> Invoke(Vector512<ushort> lower, Vector512<ushort> upper) => Vector512.Narrow(lower, upper); 170public static Vector512<sbyte> Invoke(Vector512<short> lower, Vector512<short> upper) => Vector512.Narrow(lower, upper); 181public static Vector512<ushort> Invoke(Vector512<uint> lower, Vector512<uint> upper) => Vector512.Narrow(lower, upper); 192public static Vector512<short> Invoke(Vector512<int> lower, Vector512<int> upper) => Vector512.Narrow(lower, upper); 203public static Vector512<uint> Invoke(Vector512<ulong> lower, Vector512<ulong> upper) => Vector512.Narrow(lower, upper); 214public static Vector512<int> Invoke(Vector512<long> lower, Vector512<long> upper) => Vector512.Narrow(lower, upper); 225public static Vector512<TTo> Invoke(Vector512<TFrom> x) => throw new NotSupportedException();

72public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)

101public static Vector512<T> Invoke(Vector512<T> x)

122public static Vector512<T> Invoke(Vector512<T> t) 126Vector512<float> x = t.AsSingle(); 128Vector512<float> y = Vector512.Abs(x); 129Vector512<float> z = ExpOperator<float>.Invoke(y - Vector512.Create((float)Single_LOGV)); 135Vector512<double> x = t.AsDouble(); 137Vector512<double> y = Vector512.Abs(x); 138Vector512<double> z = ExpOperator<double>.Invoke(y - Vector512.Create(Double_LOGV));

61if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 66Vector512<T> dotProductVector = Vector512<T>.Zero; 67Vector512<T> xSumOfSquaresVector = Vector512<T>.Zero; 68Vector512<T> ySumOfSquaresVector = Vector512<T>.Zero; 71int oneVectorFromEnd = x.Length - Vector512<T>.Count; 80i += Vector512<T>.Count; 87Vector512<T> remainderMask = CreateRemainderMaskVector512<T>(x.Length - i); 90Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)) & remainderMask, 91Vector512.LoadUnsafe(ref yRef, (uint)(x.Length - Vector512<T>.Count)) & remainderMask, 201if (Vector512.IsHardwareAccelerated && x.Length >= Vector512<short>.Count) 207Vector512<float> dotProductVector = Vector512<float>.Zero; 208Vector512<float> xSumOfSquaresVector = Vector512<float>.Zero; 209Vector512<float> ySumOfSquaresVector = Vector512<float>.Zero; 212int oneVectorFromEnd = x.Length - Vector512<short>.Count; 216(Vector512<float> xVecLower, Vector512<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i)); 217(Vector512<float> yVecLower, Vector512<float> yVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(Vector512.LoadUnsafe(ref yRef, (uint)i)); 222i += Vector512<short>.Count; 229Vector512<short> remainderMask = CreateRemainderMaskVector512<short>(x.Length - i); 231(Vector512<float> xVecLower, Vector512<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke( 232Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<short>.Count)) & remainderMask); 233(Vector512<float> yVecLower, Vector512<float> yVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke( 234Vector512.LoadUnsafe(ref yRef, (uint)(x.Length - Vector512<short>.Count)) & remainderMask); 363private static void Update<T>(Vector512<T> xVec, Vector512<T> yVec, ref Vector512<T> dotProductVector, ref Vector512<T> xSumOfSquaresVector, ref Vector512<T> ySumOfSquaresVector) where T : INumberBase<T> 383private static T Finalize<T>(Vector512<T> dotProductVector, Vector512<T> xSumOfSquaresVector, Vector512<T> ySumOfSquaresVector) where T : IRootFunctions<T> =>

94public static Vector512<T> Invoke(Vector512<T> x) 96Vector512<T> xpi = x * Vector512.Create(T.Pi);

39public static Vector512<T> Invoke(Vector512<T> x) => x - Vector512<T>.One;

65public static Vector512<T> Invoke(Vector512<T> x)

68public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) 70Vector512<T> tmp = x - y;

98public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x / y;

96public static (Vector512<T>, Vector512<T>) Invoke(Vector512<T> x, Vector512<T> y) 98Vector512<T> quotient = x / y;

75public static Vector512<T> Invoke(Vector512<T> x)

46public static Vector512<T> Invoke(Vector512<T> x) => ExpOperator<T>.Invoke(x * Vector512.Create(T.CreateTruncating(NaturalLog10)));

44public static Vector512<T> Invoke(Vector512<T> x) => Exp10Operator<T>.Invoke(x) - Vector512<T>.One;

46public static Vector512<T> Invoke(Vector512<T> x) => ExpOperator<T>.Invoke(x * Vector512.Create(T.CreateTruncating(NaturalLog2)));

44public static Vector512<T> Invoke(Vector512<T> x) => Exp2Operator<T>.Invoke(x) - Vector512<T>.One;

44public static Vector512<T> Invoke(Vector512<T> x) => ExpOperator<T>.Invoke(x) - Vector512<T>.One;

16private static Vector512<float> ApplyScalar<TOperator>(Vector512<float> floats) where TOperator : IUnaryOperator<float, float> => 25private static Vector512<double> ApplyScalar<TOperator>(Vector512<double> doubles) where TOperator : IUnaryOperator<double, double> => 54private static (Vector512<float> First, Vector512<float> Second) Apply2xScalar<TOperator>(Vector512<float> floats) 90private static (Vector512<double> First, Vector512<double> Second) Apply2xScalar<TOperator>(Vector512<double> doubles)

64public static Vector512<T> Invoke(Vector512<T> x)

150public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z)

335public static Vector512<short> Invoke(Vector512<short> x) 337(Vector512<float> xVecLower, Vector512<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(x); 373public static Vector512<short> Invoke(Vector512<short> x, Vector512<short> y) 375(Vector512<float> xVecLower, Vector512<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(x); 376(Vector512<float> yVecLower, Vector512<float> yVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(y); 412public static Vector512<short> Invoke(Vector512<short> x, Vector512<short> y) 414(Vector512<float> xVecLower, Vector512<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(x); 415(Vector512<float> yVecLower, Vector512<float> yVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(y); 437public static short Invoke(Vector512<short> x) 439(Vector512<float> xVecLower, Vector512<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(x); 480public static Vector512<short> Invoke(Vector512<short> x, Vector512<short> y, Vector512<short> z) 482(Vector512<float> xVecLower, Vector512<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(x); 483(Vector512<float> yVecLower, Vector512<float> yVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(y); 484(Vector512<float> zVecLower, Vector512<float> zVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(z);

79if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 84int oneVectorFromEnd = x.Length - Vector512<T>.Count; 88Vector512<T> xVec = Vector512.LoadUnsafe(ref xRef, (uint)i); 89Vector512<T> yVec = Vector512.LoadUnsafe(ref yRef, (uint)i); 93i += Vector512<T>.Count; 100Vector512<T> xVec = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 101Vector512<T> yVec = Vector512.LoadUnsafe(ref yRef, (uint)(x.Length - Vector512<T>.Count)); 103Vector512<T> remainderMask = CreateRemainderMaskVector512<T>(x.Length - i);

69public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)

65public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => throw new NotSupportedException();

42public static Vector512<int> Invoke(Vector512<T> x) => throw new NotSupportedException(); 53public static Vector512<int> Invoke(Vector512<double> lower, Vector512<double> upper) => throw new NotSupportedException();

39public static Vector512<T> Invoke(Vector512<T> x) => x + Vector512<T>.One;

34public static T Aggregate(Vector512<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x); 78public static Vector512<T> Compare(Vector512<T> x, Vector512<T> y) 82Vector512<T> equalResult = Vector512.IsPositive(x) & Vector512.IsNegative(y); 98private static int IndexOfFirstMatch<T>(Vector512<T> mask) => 136private static unsafe Vector512<T> ElementWiseSelect<T>(Vector512<T> mask, Vector512<T> left, Vector512<T> right)

33public static T Aggregate(Vector512<T> x) => HorizontalAggregate<T, MaxMagnitudeOperator<T>>(x); 112public static Vector512<T> Compare(Vector512<T> x, Vector512<T> y) 114Vector512<T> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y); 117Vector512<T> equalResult = Vector512.IsPositive(x) & Vector512.IsNegative(y); 127Vector512<T> equalResult = Vector512.IsPositive(x) & Vector512.IsNegative(y); 128Vector512<T> nonOverflowResult = Vector512.GreaterThan(xMag, yMag) | (Vector512.Equals(xMag, yMag) & equalResult);

33public static T Aggregate(Vector512<T> x) => HorizontalAggregate<T, MinOperator<T>>(x); 77public static Vector512<T> Compare(Vector512<T> x, Vector512<T> y) 81Vector512<T> equalResult = Vector512.IsNegative(x) & Vector512.IsPositive(y);

33public static T Aggregate(Vector512<T> x) => HorizontalAggregate<T, MinMagnitudeOperator<T>>(x); 112public static Vector512<T> Compare(Vector512<T> x, Vector512<T> y) 114Vector512<T> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y); 117Vector512<T> equalResult = Vector512.IsNegative(x) & Vector512.IsPositive(y); 127Vector512<T> equalResult = Vector512.IsNegative(x) & Vector512.IsPositive(y); 128Vector512<T> nonOverflowResult = Vector512.LessThan(xMag, yMag) | (Vector512.Equals(xMag, yMag) & equalResult);

70public static Vector512<T> Invoke(Vector512<T> x) => Vector512<T>.AllBitsSet;

71public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();

53public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsEvenInteger(x);

72public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsFinite(x);

71public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();

59public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsInfinity(x);

70public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsInteger(x);

70public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsNaN<T>(x);

74public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsNegative<T>(x);

59public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsNegativeInfinity(x);

56public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsNormal(x);

53public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsOddInteger(x);

52public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsPositive<T>(x);

59public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsPositiveInfinity(x);

62public static Vector512<T> Invoke(Vector512<T> x) => 63Vector512.Equals(x & (x - Vector512<T>.One), Vector512<T>.Zero) & 64Vector512.GreaterThan(x, Vector512<T>.Zero);

70public static Vector512<T> Invoke(Vector512<T> x) => ~Vector512.IsNaN(x);

59public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsSubnormal(x);

52public static Vector512<T> Invoke(Vector512<T> x) => Vector512.Equals(x, Vector512<T>.Zero);

161public static Vector512<T> Invoke(Vector512<T> x) 170Vector512<byte> lookupVectorA = 179Vector512<byte> lookupVectorB = Vector512.Create((byte)1); 180Vector512<byte> bit7ZeroMask = Avx512BW.CompareLessThan(x.AsByte(), Vector512.Create((byte)128)); 188Vector512<uint> lowHalf = Vector512.Create((uint)0x0000FFFF); 189Vector512<uint> x_bot16 = (x.AsUInt32() << 16) | lowHalf; 190Vector512<uint> x_top16 = x.AsUInt32() | lowHalf; 191Vector512<uint> lz_bot16 = Avx512CD.LeadingZeroCount(x_bot16); 192Vector512<uint> lz_top16 = Avx512CD.LeadingZeroCount(x_top16); 193Vector512<uint> lz_top16_shift = lz_top16 << 16;

129public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> amount)

131public static Vector512<T> Invoke(Vector512<T> x) 153public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => LogOperator<T>.Invoke(x) / LogOperator<T>.Invoke(y);

50public static Vector512<T> Invoke(Vector512<T> x) => LogOperator<T>.Invoke(x) / Vector512.Create(T.CreateTruncating(NaturalLog10));

49public static Vector512<T> Invoke(Vector512<T> x) => Log10Operator<T>.Invoke(x + Vector512<T>.One);

77public static Vector512<T> Invoke(Vector512<T> x)

49public static Vector512<T> Invoke(Vector512<T> x) => Log2Operator<T>.Invoke(x + Vector512<T>.One);

49public static Vector512<T> Invoke(Vector512<T> x) => LogOperator<T>.Invoke(x + Vector512<T>.One);

115public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => Vector512.Max(x, y); 119public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x); 140if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 146Vector512<T> result = Vector512.LoadUnsafe(ref xRef, 0); 147Vector512<T> current; 149Vector512<T> nanMask; 154if (nanMask != Vector512<T>.Zero) 160int oneVectorFromEnd = x.Length - Vector512<T>.Count; 161int i = Vector512<T>.Count; 173if (nanMask != Vector512<T>.Zero) 180i += Vector512<T>.Count; 186current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 192if (nanMask != Vector512<T>.Zero)

109public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) 116public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MaxMagnitudeOperator<T>>(x);

124public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) 131public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MaxMagnitudeNumberOperator<T>>(x);

117public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) 124public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MaxNumberOperator<T>>(x);

114public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => Vector512.Min(x, y); 118public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MinOperator<T>>(x);

119public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) 126public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MinMagnitudeOperator<T>>(x);

124public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) 131public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MinMagnitudeNumberOperator<T>>(x);

117public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) 124public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MinNumberOperator<T>>(x);

71public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x * y; 75public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MultiplyOperator<T>>(x);

103public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z) => (x * y) + z;

154public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z)

41public static Vector512<T> Invoke(Vector512<T> x) => -x;

38public static Vector512<T> Invoke(Vector512<T> x) => ~x;

184public static Vector512<T> Invoke(Vector512<T> x) 188Vector512<byte> c1 = Vector512.Create((byte)0x55); 189Vector512<byte> c2 = Vector512.Create((byte)0x33); 190Vector512<byte> c3 = Vector512.Create((byte)0x0F); 196Vector512<byte> tmp = x.AsByte(); 204Vector512<ushort> c1 = Vector512.Create((ushort)0x5555); 205Vector512<ushort> c2 = Vector512.Create((ushort)0x3333); 206Vector512<ushort> c3 = Vector512.Create((ushort)0x0F0F); 207Vector512<ushort> c4 = Vector512.Create((ushort)0x0101); 209Vector512<ushort> tmp = x.AsUInt16(); 218Vector512<uint> c1 = Vector512.Create(0x55555555u); 219Vector512<uint> c2 = Vector512.Create(0x33333333u); 220Vector512<uint> c3 = Vector512.Create(0x0F0F0F0Fu); 221Vector512<uint> c4 = Vector512.Create(0x01010101u); 223Vector512<uint> tmp = x.AsUInt32();

92public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)

58public static Vector512<T> Invoke(Vector512<T> x)

106public static Vector512<T> Invoke(Vector512<T> x) => Vector512<T>.One / x; 115public static Vector512<T> Invoke(Vector512<T> x) => Vector512<T>.One / Vector512.Sqrt(x); 166public static Vector512<T> Invoke(Vector512<T> x) 174return Vector512<T>.One / x; 226public static Vector512<T> Invoke(Vector512<T> x) 234return Vector512<T>.One / Vector512.Sqrt(x);

107public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) =>

61public Vector512<T> Invoke(Vector512<T> x)

50public Vector512<T> Invoke(Vector512<T> x) => (x << _amount) | (x >>> ((sizeof(T) * 8) - _amount)); 63public Vector512<T> Invoke(Vector512<T> x) => (x >>> _amount) | (x << ((sizeof(T) * 8) - _amount));

172public static Vector512<T> Invoke(Vector512<T> x) 229public static Vector512<T> Invoke(Vector512<T> x) 256public Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();

36public Vector512<T> Invoke(Vector512<T> x) => x * Vector512.Create(_pow2n);

35public Vector512<T> Invoke(Vector512<T> x) => x << _amount;

35public Vector512<T> Invoke(Vector512<T> x) => x >> _amount;

35public Vector512<T> Invoke(Vector512<T> x) => x >>> _amount;

48public static Vector512<T> Invoke(Vector512<T> x) => Vector512.Create(T.One) / (Vector512.Create(T.One) + ExpOperator<T>.Invoke(-x));

90public static Vector512<int> Invoke(Vector512<T> x) 94return Vector512.ConditionalSelect(Vector512.Equals(x, Vector512<T>.Zero).AsInt32(), 95Vector512<int>.Zero, 96Vector512<int>.One); 101Vector512<int> value = x.AsInt32(); 105if (Vector512.EqualsAny(Vector512.IsNaN(x).AsInt32(), Vector512<int>.AllBitsSet)) 110return Vector512.ConditionalSelect(Vector512.LessThan(x, Vector512<T>.Zero).AsInt32(), 112Vector512.ConditionalSelect(Vector512.GreaterThan(x, Vector512<T>.Zero).AsInt32(), 113Vector512<int>.One, 114Vector512<int>.Zero));

91public static Vector512<T> Invoke(Vector512<T> x)

37public static (Vector512<T> First, Vector512<T> Second) Invoke(Vector512<T> x) => throw new NotSupportedException();

37public static (Vector512<T> First, Vector512<T> Second) Invoke(Vector512<T> x) => throw new NotSupportedException();

112public static Vector512<T> Invoke(Vector512<T> t) 116Vector512<float> x = t.AsSingle(); 118Vector512<float> y = Vector512.Abs(x); 119Vector512<float> z = ExpOperator<float>.Invoke(y - Vector512.Create((float)Single_LOGV)); 120Vector512<float> result = Vector512.Create((float)Single_HALFV) * (z - (Vector512.Create((float)Single_INVV2) / z)); 121Vector512<uint> sign = x.AsUInt32() & Vector512.Create(~(uint)int.MaxValue); 127Vector512<double> x = t.AsDouble(); 129Vector512<double> y = Vector512.Abs(x); 130Vector512<double> z = ExpOperator<double>.Invoke(y - Vector512.Create(Double_LOGV)); 131Vector512<double> result = Vector512.Create(Double_HALFV) * (z - (Vector512.Create(Double_INVV2) / z)); 132Vector512<ulong> sign = x.AsUInt64() & Vector512.Create(~(ulong)long.MaxValue);

94public static Vector512<T> Invoke(Vector512<T> x) 96Vector512<T> xpi = x * Vector512.Create(T.Pi);

39public static Vector512<T> Invoke(Vector512<T> x) => Vector512.Sqrt(x);

60public Vector512<T> Invoke(Vector512<T> x) 62Vector512<T> diff = x - Vector512.Create(_subtrahend);

94public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x - y;

78public static Vector512<T> Invoke(Vector512<T> x) => x * x;

94public static Vector512<T> Invoke(Vector512<T> x) 198public static Vector512<float> Invoke(Vector512<float> x) 200Vector512<float> uxMasked = Vector512.Abs(x); 206Vector512<float> dn = MultiplyAddEstimateOperator<float>.Invoke(uxMasked, Vector512.Create(2 / float.Pi), Vector512.Create(AlmHuge)); 207Vector512<uint> odd = dn.AsUInt32() << 31; 210Vector512<float> f = uxMasked; 216Vector512<float> f2 = f * f; 217Vector512<float> f4 = f2 * f2; 218Vector512<float> f8 = f4 * f4; 219Vector512<float> f12 = f8 * f4; 220Vector512<float> a1 = MultiplyAddEstimateOperator<float>.Invoke(Vector512.Create(C2), f2, Vector512.Create(C1)); 221Vector512<float> a2 = MultiplyAddEstimateOperator<float>.Invoke(Vector512.Create(C4), f2, Vector512.Create(C3)); 222Vector512<float> a3 = MultiplyAddEstimateOperator<float>.Invoke(Vector512.Create(C6), f2, Vector512.Create(C5)); 223Vector512<float> b1 = MultiplyAddEstimateOperator<float>.Invoke(a2, f4, a1); 224Vector512<float> b2 = MultiplyAddEstimateOperator<float>.Invoke(f8, a3, f12 * Vector512.Create(C7)); 225Vector512<float> poly = MultiplyAddEstimateOperator<float>.Invoke(f * f2, b1 + b2, f); 227Vector512<float> result = (poly.AsUInt32() ^ (x.AsUInt32() & Vector512.Create(~SignMask))).AsSingle(); 228return Vector512.ConditionalSelect(Vector512.Equals(odd, Vector512<uint>.Zero).AsSingle(), 355public static Vector512<double> Invoke(Vector512<double> x) 357Vector512<double> uxMasked = Vector512.Abs(x); 364Vector512<double> dn = MultiplyAddEstimateOperator<double>.Invoke(uxMasked, Vector512.Create(2 / double.Pi), Vector512.Create(AlmHuge)); 365Vector512<ulong> odd = dn.AsUInt64() << 63; 369Vector512<double> f = uxMasked; 375Vector512<double> g = f * f; 376Vector512<double> g2 = g * g; 377Vector512<double> g3 = g * g2; 378Vector512<double> g5 = g3 * g2; 379Vector512<double> g7 = g5 * g2; 380Vector512<double> g9 = g7 * g2; 381Vector512<double> g11 = g9 * g2; 382Vector512<double> g13 = g11 * g2; 383Vector512<double> a1 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C3), g, Vector512.Create(C1)); 384Vector512<double> a2 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C7), g, Vector512.Create(C5)); 385Vector512<double> a3 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C11), g, Vector512.Create(C9)); 386Vector512<double> a4 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C15), g, Vector512.Create(C13)); 387Vector512<double> a5 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C19), g, Vector512.Create(C17)); 388Vector512<double> a6 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C23), g, Vector512.Create(C21)); 389Vector512<double> a7 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C27), g, Vector512.Create(C25)); 390Vector512<double> b1 = MultiplyAddEstimateOperator<double>.Invoke(g, a1, g3 * a2); 391Vector512<double> b2 = MultiplyAddEstimateOperator<double>.Invoke(g5, a3, g7 * a4); 392Vector512<double> b3 = MultiplyAddEstimateOperator<double>.Invoke(g9, a5, g11 * a6); 393Vector512<double> q = MultiplyAddEstimateOperator<double>.Invoke(g13, a7, b1 + b2 + b3); 394Vector512<double> poly = MultiplyAddEstimateOperator<double>.Invoke(f, q, f); 396Vector512<double> result = (poly.AsUInt64() ^ (x.AsUInt64() & Vector512.Create(~SignMask))).AsDouble(); 397return Vector512.ConditionalSelect(Vector512.Equals(odd, Vector512<ulong>.Zero).AsDouble(),

114public static Vector512<T> Invoke(Vector512<T> t) 118Vector512<float> x = t.AsSingle(); 120Vector512<float> y = Vector512.Abs(x); 121Vector512<float> z = ExpM1Operator<float>.Invoke(Vector512.Create(-2f) * y); 122Vector512<uint> sign = x.AsUInt32() & Vector512.Create(~(uint)int.MaxValue); 127Vector512<double> x = t.AsDouble(); 129Vector512<double> y = Vector512.Abs(x); 130Vector512<double> z = ExpM1Operator<double>.Invoke(Vector512.Create(-2d) * y); 131Vector512<ulong> sign = x.AsUInt64() & Vector512.Create(~(ulong)long.MaxValue);

46public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();

56public static Vector512<T> Invoke(Vector512<T> x) 59return PopCountOperator<T>.Invoke(~x & (x - Vector512<T>.One));

66public static Vector512<T> Invoke(Vector512<T> x)

63public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x ^ y;

853Vector512<sbyte> vbmiLookup0 = Vector512.Create(decoder.VbmiLookup0).AsSByte(); 854Vector512<sbyte> vbmiLookup1 = Vector512.Create(decoder.VbmiLookup1).AsSByte(); 855Vector512<byte> vbmiPackedLanesControl = Vector512.Create( 861Vector512<sbyte> mergeConstant0 = Vector512.Create(0x01400140).AsSByte(); 862Vector512<short> mergeConstant1 = Vector512.Create(0x00011000).AsInt16(); 868if (!decoder.TryLoadVector512(src, srcStart, sourceLength, out Vector512<sbyte> str)) 877Vector512<sbyte> origIndex = Avx512Vbmi.PermuteVar64x8x2(vbmiLookup0, str, vbmiLookup1); 878Vector512<sbyte> errorVec = (origIndex.AsInt32() | str.AsInt32()).AsSByte(); 886Vector512<short> multiAdd1 = Avx512BW.MultiplyAddAdjacent(origIndex.AsByte(), mergeConstant0); 888Vector512<int> multiAdd2 = Avx512BW.MultiplyAddAdjacent(multiAdd1, mergeConstant1); 893AssertWrite<Vector512<sbyte>>(dest, destStart, destLength); 1547public unsafe bool TryLoadVector512(byte* src, byte* srcStart, int sourceLength, out Vector512<sbyte> str) 1549AssertRead<Vector512<sbyte>>(src, srcStart, sourceLength); 1717public unsafe bool TryLoadVector512(ushort* src, ushort* srcStart, int sourceLength, out Vector512<sbyte> str) 1719AssertRead<Vector512<ushort>>(src, srcStart, sourceLength); 1720Vector512<ushort> utf16VectorLower = Vector512.Load(src); 1721Vector512<ushort> utf16VectorUpper = Vector512.Load(src + 32);

152Vector512<sbyte> shuffleVecVbmi = Vector512.Create( 157Vector512<sbyte> vbmiLookup = Vector512.Create(encoder.EncodingMap).AsSByte(); 159Vector512<ushort> maskAC = Vector512.Create((uint)0x0fc0fc00).AsUInt16(); 160Vector512<uint> maskBB = Vector512.Create((uint)0x3f003f00); 161Vector512<ushort> shiftAC = Vector512.Create((uint)0x0006000a).AsUInt16(); 162Vector512<ushort> shiftBB = Vector512.Create((uint)0x00080004).AsUInt16(); 170Vector512<sbyte> str = Vector512.Load(src).AsSByte(); 181Vector512<ushort> temp1 = (str.AsUInt16() & maskAC); 184Vector512<ushort> temp2 = Avx512BW.ShiftRightLogicalVariable(temp1, shiftAC).AsUInt16(); 187Vector512<ushort> temp3 = Avx512BW.ShiftLeftLogicalVariable(str.AsUInt16(), shiftBB).AsUInt16(); 203AssertRead<Vector512<sbyte>>(src, srcStart, sourceLength); 777public unsafe void StoreVector512ToDestination(byte* dest, byte* destStart, int destLength, Vector512<byte> str) 779AssertWrite<Vector512<sbyte>>(dest, destStart, destLength); 856public unsafe void StoreVector512ToDestination(ushort* dest, ushort* destStart, int destLength, Vector512<byte> str) 858AssertWrite<Vector512<short>>(dest, destStart, destLength); 859(Vector512<ushort> utf16LowVector, Vector512<ushort> utf16HighVector) = Vector512.Widen(str);

97unsafe void StoreVector512ToDestination(T* dest, T* destStart, int destLength, Vector512<byte> str); 143unsafe bool TryLoadVector512(T* src, T* srcStart, int sourceLength, out Vector512<sbyte> str);

448public unsafe bool TryLoadVector512(byte* src, byte* srcStart, int sourceLength, out Vector512<sbyte> str) => 533public unsafe bool TryLoadVector512(ushort* src, ushort* srcStart, int sourceLength, out Vector512<sbyte> str) =>

298public unsafe void StoreVector512ToDestination(byte* dest, byte* destStart, int destLength, Vector512<byte> str) => 355public unsafe void StoreVector512ToDestination(ushort* dest, ushort* destStart, int destLength, Vector512<byte> str) =>

231while (valuesAsBytes.Length >= Vector512<byte>.Count) 233Vector512<byte> vector = Vector512.Create(valuesAsBytes); 234Vector512<byte> isFalse = Vector512.Equals(vector, Vector512<byte>.Zero); 238i += (uint)Vector512<byte>.Count; 239valuesAsBytes = valuesAsBytes.Slice(Vector512<byte>.Count); 520i = Apply<Vector512<byte>>(count, thisArray, valueArray); 837if (Vector512.IsHardwareAccelerated && (uint)_bitLength >= Vector512<byte>.Count) 842Vector512<byte> shuffleMask = Vector512.Create(lowerShuffleMask_CopyToBoolArray256, upperShuffleMask_CopyToBoolArray256); 843Vector512<byte> bitMask = Vector512.Create(0x80402010_08040201).AsByte(); 844Vector512<byte> ones = Vector512<byte>.One; 848for (; (i + Vector512<byte>.Count) <= (uint)_bitLength; i += (uint)Vector512<byte>.Count) 851Vector512<ulong> scalar = Vector512.Create(bits); 852Vector512<byte> shuffled = Vector512.Shuffle(scalar.AsByte(), shuffleMask); 853Vector512<byte> extracted = shuffled & bitMask; 857Vector512<byte> normalized = Vector512.Min(extracted, ones);

167if (Vector512.IsHardwareAccelerated && length >= Vector512<ushort>.Count) 169return EqualsIgnoreCase_Vector<Vector512<ushort>>(ref charA, ref charB, length);

205static abstract Vector512<T> Compare(Vector512<T> left, Vector512<T> right); 213public static Vector512<T> Compare(Vector512<T> left, Vector512<T> right) => Vector512.Min(left, right); 221public static Vector512<T> Compare(Vector512<T> left, Vector512<T> right) => Vector512.Max(left, right); 270else if (!Vector512.IsHardwareAccelerated || span.Length < Vector512<T>.Count) 289Vector512<T> best = Vector512.Create(data); 290data = data.Slice(Vector512<T>.Count); 292while (data.Length > Vector512<T>.Count) 295data = data.Slice(Vector512<T>.Count); 297best = TMinMax.Compare(best, Vector512.Create(span.Slice(span.Length - Vector512<T>.Count)));

125while (Vector512.IsHardwareAccelerated && remaining.Length >= Vector512<nuint>.Count + 1) 127Vector512<nuint> current = Vector512.Create(remaining) >> shift; 128Vector512<nuint> carries = Vector512.Create(remaining.Slice(1)) << back; 130Vector512<nuint> newValue = current | carries; 133remaining = remaining.Slice(Vector512<nuint>.Count);

470if (Vector<double>.Count == Vector512<double>.Count) 493if (Vector<double>.Count == Vector512<double>.Count) 601if (Vector<float>.Count == Vector512<float>.Count) 764if (Vector<T>.Count == Vector512<T>.Count) 883if (Vector<T>.Count == Vector512<T>.Count) 938if (Vector<T>.Count == Vector512<T>.Count) 962if (Vector<T>.Count == Vector512<T>.Count) 986if (Vector<T>.Count == Vector512<T>.Count) 1010if (Vector<T>.Count == Vector512<T>.Count) 1034if (Vector<T>.Count == Vector512<T>.Count) 1058if (Vector<T>.Count == Vector512<T>.Count) 1091if (Vector<T>.Count == Vector512<T>.Count) 1115if (Vector<T>.Count == Vector512<T>.Count) 1147if (Vector<T>.Count == Vector512<T>.Count) 1701if (Vector<T>.Count == Vector512<T>.Count) 1939if (Vector<T>.Count == Vector512<T>.Count) 2981if (Vector<uint>.Count == Vector512<uint>.Count) 3007if (Vector<ulong>.Count == Vector512<ulong>.Count)

834return VectorMath.AsinSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 875return VectorMath.CosSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 1853return VectorMath.DegreesToRadiansSingle<Vector256<float>, Vector512<double>>(degrees); 1960return VectorMath.ExpSingle<Vector256<float>, Vector256<uint>, Vector512<double>, Vector512<ulong>>(vector); 2204return VectorMath.HypotSingle<Vector256<float>, Vector512<double>>(x, y); 3183return VectorMath.RadiansToDegreesSingle<Vector256<float>, Vector512<double>>(radians); 3638return VectorMath.SinSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 3682return VectorMath.SinCosSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 3837/// <summary>Converts the given vector to a new <see cref="Vector512{T}" /> with the lower 256-bits set to the value of the given vector and the upper 256-bits initialized to zero.</summary> 3840/// <returns>A new <see cref="Vector512{T}" /> with the lower 256-bits set to the value of <paramref name="vector" /> and the upper 256-bits initialized to zero.</returns> 3843public static Vector512<T> ToVector512<T>(this Vector256<T> vector) 3847Vector512<T> result = default; 3852/// <summary>Converts the given vector to a new <see cref="Vector512{T}" /> with the lower 256-bits set to the value of the given vector and the upper 256-bits left uninitialized.</summary> 3855/// <returns>A new <see cref="Vector512{T}" /> with the lower 256-bits set to the value of <paramref name="vector" /> and the upper 256-bits left uninitialized.</returns> 3858public static Vector512<T> ToVector512Unsafe<T>(this Vector256<T> vector) 3865Unsafe.SkipInit(out Vector512<T> result);

31public readonly unsafe struct Vector512<T> : ISimdVector<Vector512<T>, T> 36/// <summary>Gets a new <see cref="Vector512{T}" /> with all bits set to 1.</summary> 38public static Vector512<T> AllBitsSet 44/// <summary>Gets the number of <typeparamref name="T" /> that are in a <see cref="Vector512{T}" />.</summary> 56/// <summary>Gets a new <see cref="Vector512{T}" /> with the elements set to their index.</summary> 58public static Vector512<T> Indices 65Unsafe.SkipInit(out Vector512<T> result); 99/// <summary>Gets a new <see cref="Vector512{T}" /> with all elements initialized to one.</summary> 101public static Vector512<T> One 107/// <summary>Gets a new <see cref="Vector512{T}" /> with all elements initialized to zero.</summary> 109public static Vector512<T> Zero 135public static Vector512<T> operator +(Vector512<T> left, Vector512<T> right) 150public static Vector512<T> operator &(Vector512<T> left, Vector512<T> right) 165public static Vector512<T> operator |(Vector512<T> left, Vector512<T> right) 180public static Vector512<T> operator /(Vector512<T> left, Vector512<T> right) 194public static Vector512<T> operator /(Vector512<T> left, T right) 209public static bool operator ==(Vector512<T> left, Vector512<T> right) 222public static Vector512<T> operator ^(Vector512<T> left, Vector512<T> right) 236public static bool operator !=(Vector512<T> left, Vector512<T> right) => !(left == right); 244public static Vector512<T> operator <<(Vector512<T> value, int shiftCount) 259public static Vector512<T> operator *(Vector512<T> left, Vector512<T> right) 274public static Vector512<T> operator *(Vector512<T> left, T right) 288public static Vector512<T> operator *(T left, Vector512<T> right) => right * left; 296public static Vector512<T> operator ~(Vector512<T> vector) 310public static Vector512<T> operator >>(Vector512<T> value, int shiftCount) 325public static Vector512<T> operator -(Vector512<T> left, Vector512<T> right) 339public static Vector512<T> operator -(Vector512<T> vector) 343return vector ^ Vector512<float>.NegativeZero.As<float, T>(); 347return vector ^ Vector512<double>.NegativeZero.As<double, T>(); 360public static Vector512<T> operator +(Vector512<T> value) 372public static Vector512<T> operator >>>(Vector512<T> value, int shiftCount) 382/// <returns><c>true</c> if <paramref name="obj" /> is a <see cref="Vector512{T}" /> and is equal to the current instance; otherwise, <c>false</c>.</returns> 383public override bool Equals([NotNullWhen(true)] object? obj) => (obj is Vector512<T> other) && Equals(other); 385/// <summary>Determines whether the specified <see cref="Vector512{T}" /> is equal to the current instance.</summary> 386/// <param name="other">The <see cref="Vector512{T}" /> to compare with the current instance.</param> 390public bool Equals(Vector512<T> other) 399Vector512<T> result = Vector512.Equals(this, other) | ~(Vector512.Equals(this, this) | Vector512.Equals(other, other)); 400return result.AsInt32() == Vector512<int>.AllBitsSet; 461static int ISimdVector<Vector512<T>, T>.Alignment => Vector512.Alignment; 464static int ISimdVector<Vector512<T>, T>.ElementCount => Vector512<T>.Count; 467static bool ISimdVector<Vector512<T>, T>.IsHardwareAccelerated 475static Vector512<T> ISimdVector<Vector512<T>, T>.Abs(Vector512<T> vector) => Vector512.Abs(vector); 479static Vector512<T> ISimdVector<Vector512<T>, T>.Add(Vector512<T> left, Vector512<T> right) => left + right; 483static bool ISimdVector<Vector512<T>, T>.All(Vector512<T> vector, T value) => Vector512.All(vector, value); 487static bool ISimdVector<Vector512<T>, T>.AllWhereAllBitsSet(Vector512<T> vector) => Vector512.AllWhereAllBitsSet(vector); 491static Vector512<T> ISimdVector<Vector512<T>, T>.AndNot(Vector512<T> left, Vector512<T> right) => Vector512.AndNot(left, right); 495static bool ISimdVector<Vector512<T>, T>.Any(Vector512<T> vector, T value) => Vector512.Any(vector, value); 499static bool ISimdVector<Vector512<T>, T>.AnyWhereAllBitsSet(Vector512<T> vector) => Vector512.AnyWhereAllBitsSet(vector); 503static Vector512<T> ISimdVector<Vector512<T>, T>.BitwiseAnd(Vector512<T> left, Vector512<T> right) => left & right; 507static Vector512<T> ISimdVector<Vector512<T>, T>.BitwiseOr(Vector512<T> left, Vector512<T> right) => left | right; 511static Vector512<T> ISimdVector<Vector512<T>, T>.Ceiling(Vector512<T> vector) => Vector512.Ceiling(vector); 515static Vector512<T> ISimdVector<Vector512<T>, T>.Clamp(Vector512<T> value, Vector512<T> min, Vector512<T> max) => Vector512.Clamp(value, min, max); 519static Vector512<T> ISimdVector<Vector512<T>, T>.ClampNative(Vector512<T> value, Vector512<T> min, Vector512<T> max) => Vector512.ClampNative(value, min, max); 523static Vector512<T> ISimdVector<Vector512<T>, T>.ConditionalSelect(Vector512<T> condition, Vector512<T> left, Vector512<T> right) => Vector512.ConditionalSelect(condition, left, right); 527static Vector512<T> ISimdVector<Vector512<T>, T>.CopySign(Vector512<T> value, Vector512<T> sign) => Vector512.CopySign(value, sign); 530static void ISimdVector<Vector512<T>, T>.CopyTo(Vector512<T> vector, T[] destination) => vector.CopyTo(destination); 533static void ISimdVector<Vector512<T>, T>.CopyTo(Vector512<T> vector, T[] destination, int startIndex) => vector.CopyTo(destination, startIndex); 536static void ISimdVector<Vector512<T>, T>.CopyTo(Vector512<T> vector, Span<T> destination) => vector.CopyTo(destination); 540static int ISimdVector<Vector512<T>, T>.Count(Vector512<T> vector, T value) => Vector512.Count(vector, value); 544static int ISimdVector<Vector512<T>, T>.CountWhereAllBitsSet(Vector512<T> vector) => Vector512.CountWhereAllBitsSet(vector); 548static Vector512<T> ISimdVector<Vector512<T>, T>.Create(T value) => Vector512.Create(value); 551static Vector512<T> ISimdVector<Vector512<T>, T>.Create(T[] values) => Vector512.Create(values); 554static Vector512<T> ISimdVector<Vector512<T>, T>.Create(T[] values, int index) => Vector512.Create(values, index); 557static Vector512<T> ISimdVector<Vector512<T>, T>.Create(ReadOnlySpan<T> values) => Vector512.Create(values); 561static Vector512<T> ISimdVector<Vector512<T>, T>.CreateScalar(T value) => Vector512.CreateScalar(value); 565static Vector512<T> ISimdVector<Vector512<T>, T>.CreateScalarUnsafe(T value) => Vector512.CreateScalarUnsafe(value); 569static Vector512<T> ISimdVector<Vector512<T>, T>.Divide(Vector512<T> left, Vector512<T> right) => left / right; 573static Vector512<T> ISimdVector<Vector512<T>, T>.Divide(Vector512<T> left, T right) => left / right; 577static T ISimdVector<Vector512<T>, T>.Dot(Vector512<T> left, Vector512<T> right) => Vector512.Dot(left, right); 581static Vector512<T> ISimdVector<Vector512<T>, T>.Equals(Vector512<T> left, Vector512<T> right) => Vector512.Equals(left, right); 585static bool ISimdVector<Vector512<T>, T>.EqualsAll(Vector512<T> left, Vector512<T> right) => left == right; 589static bool ISimdVector<Vector512<T>, T>.EqualsAny(Vector512<T> left, Vector512<T> right) => Vector512.EqualsAny(left, right); 593static Vector512<T> ISimdVector<Vector512<T>, T>.Floor(Vector512<T> vector) => Vector512.Floor(vector); 597static T ISimdVector<Vector512<T>, T>.GetElement(Vector512<T> vector, int index) => vector.GetElement(index); 601static Vector512<T> ISimdVector<Vector512<T>, T>.GreaterThan(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThan(left, right); 605static bool ISimdVector<Vector512<T>, T>.GreaterThanAll(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanAll(left, right); 609static bool ISimdVector<Vector512<T>, T>.GreaterThanAny(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanAny(left, right); 613static Vector512<T> ISimdVector<Vector512<T>, T>.GreaterThanOrEqual(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanOrEqual(left, right); 617static bool ISimdVector<Vector512<T>, T>.GreaterThanOrEqualAll(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanOrEqualAll(left, right); 621static bool ISimdVector<Vector512<T>, T>.GreaterThanOrEqualAny(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanOrEqualAny(left, right); 625static int ISimdVector<Vector512<T>, T>.IndexOf(Vector512<T> vector, T value) => Vector512.IndexOf(vector, value); 629static int ISimdVector<Vector512<T>, T>.IndexOfWhereAllBitsSet(Vector512<T> vector) => Vector512.IndexOfWhereAllBitsSet(vector); 633static Vector512<T> ISimdVector<Vector512<T>, T>.IsEvenInteger(Vector512<T> vector) => Vector512.IsEvenInteger(vector); 637static Vector512<T> ISimdVector<Vector512<T>, T>.IsFinite(Vector512<T> vector) => Vector512.IsFinite(vector); 641static Vector512<T> ISimdVector<Vector512<T>, T>.IsInfinity(Vector512<T> vector) => Vector512.IsInfinity(vector); 645static Vector512<T> ISimdVector<Vector512<T>, T>.IsInteger(Vector512<T> vector) => Vector512.IsInteger(vector); 649static Vector512<T> ISimdVector<Vector512<T>, T>.IsNaN(Vector512<T> vector) => Vector512.IsNaN(vector); 653static Vector512<T> ISimdVector<Vector512<T>, T>.IsNegative(Vector512<T> vector) => Vector512.IsNegative(vector); 657static Vector512<T> ISimdVector<Vector512<T>, T>.IsNegativeInfinity(Vector512<T> vector) => Vector512.IsNegativeInfinity(vector); 661static Vector512<T> ISimdVector<Vector512<T>, T>.IsNormal(Vector512<T> vector) => Vector512.IsNormal(vector); 665static Vector512<T> ISimdVector<Vector512<T>, T>.IsOddInteger(Vector512<T> vector) => Vector512.IsOddInteger(vector); 669static Vector512<T> ISimdVector<Vector512<T>, T>.IsPositive(Vector512<T> vector) => Vector512.IsPositive(vector); 673static Vector512<T> ISimdVector<Vector512<T>, T>.IsPositiveInfinity(Vector512<T> vector) => Vector512.IsPositiveInfinity(vector); 677static Vector512<T> ISimdVector<Vector512<T>, T>.IsSubnormal(Vector512<T> vector) => Vector512.IsSubnormal(vector); 680static Vector512<T> ISimdVector<Vector512<T>, T>.IsZero(Vector512<T> vector) => Vector512.IsZero(vector); 684static int ISimdVector<Vector512<T>, T>.LastIndexOf(Vector512<T> vector, T value) => Vector512.LastIndexOf(vector, value); 688static int ISimdVector<Vector512<T>, T>.LastIndexOfWhereAllBitsSet(Vector512<T> vector) => Vector512.LastIndexOfWhereAllBitsSet(vector); 692static Vector512<T> ISimdVector<Vector512<T>, T>.LessThan(Vector512<T> left, Vector512<T> right) => Vector512.LessThan(left, right); 696static bool ISimdVector<Vector512<T>, T>.LessThanAll(Vector512<T> left, Vector512<T> right) => Vector512.LessThanAll(left, right); 700static bool ISimdVector<Vector512<T>, T>.LessThanAny(Vector512<T> left, Vector512<T> right) => Vector512.LessThanAny(left, right); 704static Vector512<T> ISimdVector<Vector512<T>, T>.LessThanOrEqual(Vector512<T> left, Vector512<T> right) => Vector512.LessThanOrEqual(left, right); 708static bool ISimdVector<Vector512<T>, T>.LessThanOrEqualAll(Vector512<T> left, Vector512<T> right) => Vector512.LessThanOrEqualAll(left, right); 712static bool ISimdVector<Vector512<T>, T>.LessThanOrEqualAny(Vector512<T> left, Vector512<T> right) => Vector512.LessThanOrEqualAny(left, right); 716static Vector512<T> ISimdVector<Vector512<T>, T>.Load(T* source) => Vector512.Load(source); 720static Vector512<T> ISimdVector<Vector512<T>, T>.LoadAligned(T* source) => Vector512.LoadAligned(source); 724static Vector512<T> ISimdVector<Vector512<T>, T>.LoadAlignedNonTemporal(T* source) => Vector512.LoadAlignedNonTemporal(source); 728static Vector512<T> ISimdVector<Vector512<T>, T>.LoadUnsafe(ref readonly T source) => Vector512.LoadUnsafe(in source); 732static Vector512<T> ISimdVector<Vector512<T>, T>.LoadUnsafe(ref readonly T source, nuint elementOffset) => Vector512.LoadUnsafe(in source, elementOffset); 736static Vector512<T> ISimdVector<Vector512<T>, T>.Max(Vector512<T> left, Vector512<T> right) => Vector512.Max(left, right); 740static Vector512<T> ISimdVector<Vector512<T>, T>.MaxMagnitude(Vector512<T> left, Vector512<T> right) => Vector512.MaxMagnitude(left, right); 744static Vector512<T> ISimdVector<Vector512<T>, T>.MaxMagnitudeNumber(Vector512<T> left, Vector512<T> right) => Vector512.MaxMagnitudeNumber(left, right); 748static Vector512<T> ISimdVector<Vector512<T>, T>.MaxNative(Vector512<T> left, Vector512<T> right) => Vector512.MaxNative(left, right); 752static Vector512<T> ISimdVector<Vector512<T>, T>.MaxNumber(Vector512<T> left, Vector512<T> right) => Vector512.MaxNumber(left, right); 756static Vector512<T> ISimdVector<Vector512<T>, T>.Min(Vector512<T> left, Vector512<T> right) => Vector512.Min(left, right); 760static Vector512<T> ISimdVector<Vector512<T>, T>.MinMagnitude(Vector512<T> left, Vector512<T> right) => Vector512.MinMagnitude(left, right); 764static Vector512<T> ISimdVector<Vector512<T>, T>.MinMagnitudeNumber(Vector512<T> left, Vector512<T> right) => Vector512.MinMagnitudeNumber(left, right); 768static Vector512<T> ISimdVector<Vector512<T>, T>.MinNative(Vector512<T> left, Vector512<T> right) => Vector512.MinNative(left, right); 772static Vector512<T> ISimdVector<Vector512<T>, T>.MinNumber(Vector512<T> left, Vector512<T> right) => Vector512.MinNumber(left, right); 776static Vector512<T> ISimdVector<Vector512<T>, T>.Multiply(Vector512<T> left, Vector512<T> right) => left * right; 780static Vector512<T> ISimdVector<Vector512<T>, T>.Multiply(Vector512<T> left, T right) => left * right; 784static Vector512<T> ISimdVector<Vector512<T>, T>.MultiplyAddEstimate(Vector512<T> left, Vector512<T> right, Vector512<T> addend) => Vector512.MultiplyAddEstimate(left, right, addend); 788static Vector512<T> ISimdVector<Vector512<T>, T>.Negate(Vector512<T> vector) => -vector; 792static bool ISimdVector<Vector512<T>, T>.None(Vector512<T> vector, T value) => Vector512.None(vector, value); 796static bool ISimdVector<Vector512<T>, T>.NoneWhereAllBitsSet(Vector512<T> vector) => Vector512.NoneWhereAllBitsSet(vector); 800static Vector512<T> ISimdVector<Vector512<T>, T>.OnesComplement(Vector512<T> vector) => ~vector; 804static Vector512<T> ISimdVector<Vector512<T>, T>.Round(Vector512<T> vector) => Vector512.Round(vector); 808static Vector512<T> ISimdVector<Vector512<T>, T>.ShiftLeft(Vector512<T> vector, int shiftCount) => vector << shiftCount; 812static Vector512<T> ISimdVector<Vector512<T>, T>.ShiftRightArithmetic(Vector512<T> vector, int shiftCount) => vector >> shiftCount; 816static Vector512<T> ISimdVector<Vector512<T>, T>.ShiftRightLogical(Vector512<T> vector, int shiftCount) => vector >>> shiftCount; 820static Vector512<T> ISimdVector<Vector512<T>, T>.Sqrt(Vector512<T> vector) => Vector512.Sqrt(vector); 824static void ISimdVector<Vector512<T>, T>.Store(Vector512<T> source, T* destination) => source.Store(destination); 828static void ISimdVector<Vector512<T>, T>.StoreAligned(Vector512<T> source, T* destination) => source.StoreAligned(destination); 832static void ISimdVector<Vector512<T>, T>.StoreAlignedNonTemporal(Vector512<T> source, T* destination) => source.StoreAlignedNonTemporal(destination); 836static void ISimdVector<Vector512<T>, T>.StoreUnsafe(Vector512<T> vector, ref T destination) => vector.StoreUnsafe(ref destination); 840static void ISimdVector<Vector512<T>, T>.StoreUnsafe(Vector512<T> vector, ref T destination, nuint elementOffset) => vector.StoreUnsafe(ref destination, elementOffset); 844static Vector512<T> ISimdVector<Vector512<T>, T>.Subtract(Vector512<T> left, Vector512<T> right) => left - right; 848static T ISimdVector<Vector512<T>, T>.Sum(Vector512<T> vector) => Vector512.Sum(vector); 852static T ISimdVector<Vector512<T>, T>.ToScalar(Vector512<T> vector) => vector.ToScalar(); 856static Vector512<T> ISimdVector<Vector512<T>, T>.Truncate(Vector512<T> vector) => Vector512.Truncate(vector); 859static bool ISimdVector<Vector512<T>, T>.TryCopyTo(Vector512<T> vector, Span<T> destination) => vector.TryCopyTo(destination); 863static Vector512<T> ISimdVector<Vector512<T>, T>.WithElement(Vector512<T> vector, int index, T value) => vector.WithElement(index, value); 867static Vector512<T> ISimdVector<Vector512<T>, T>.Xor(Vector512<T> left, Vector512<T> right) => left ^ right;

57extension<T>(Vector512<T>) 61public static Vector512<T> E 68public static Vector512<T> Pi 75public static Vector512<T> Tau 83extension<T>(Vector512<T>) 87public static Vector512<T> Epsilon 94public static Vector512<T> NaN 101public static Vector512<T> NegativeInfinity 108public static Vector512<T> NegativeZero 115public static Vector512<T> PositiveInfinity 123extension<T>(Vector512<T>) 127public static Vector512<T> NegativeOne 134public static Vector512<T> SignSequence 149public static Vector512<T> Abs<T>(Vector512<T> vector) 166public static Vector512<T> Add<T>(Vector512<T> left, Vector512<T> right) => left + right; 171public static Vector512<T> AddSaturate<T>(Vector512<T> left, Vector512<T> right) 189public static bool All<T>(Vector512<T> vector, T value) => vector == Create(value); 194public static bool AllWhereAllBitsSet<T>(Vector512<T> vector) 218public static Vector512<T> AndNot<T>(Vector512<T> left, Vector512<T> right) => left & ~right; 223public static bool Any<T>(Vector512<T> vector, T value) => EqualsAny(vector, Create(value)); 228public static bool AnyWhereAllBitsSet<T>(Vector512<T> vector) 252public static Vector512<TTo> As<TFrom, TTo>(this Vector512<TFrom> vector) 257return Unsafe.BitCast<Vector512<TFrom>, Vector512<TTo>>(vector); 260/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Byte&gt;" />.</summary> 266public static Vector512<byte> AsByte<T>(this Vector512<T> vector) => vector.As<T, byte>(); 268/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Double&gt;" />.</summary> 274public static Vector512<double> AsDouble<T>(this Vector512<T> vector) => vector.As<T, double>(); 276/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Int16&gt;" />.</summary> 282public static Vector512<short> AsInt16<T>(this Vector512<T> vector) => vector.As<T, short>(); 284/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Int32&gt;" />.</summary> 290public static Vector512<int> AsInt32<T>(this Vector512<T> vector) => vector.As<T, int>(); 292/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Int64&gt;" />.</summary> 298public static Vector512<long> AsInt64<T>(this Vector512<T> vector) => vector.As<T, long>(); 300/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;IntPtr&gt;" />.</summary> 306public static Vector512<nint> AsNInt<T>(this Vector512<T> vector) => vector.As<T, nint>(); 308/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UIntPtr&gt;" />.</summary> 315public static Vector512<nuint> AsNUInt<T>(this Vector512<T> vector) => vector.As<T, nuint>(); 317/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;SByte&gt;" />.</summary> 324public static Vector512<sbyte> AsSByte<T>(this Vector512<T> vector) => vector.As<T, sbyte>(); 326/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Single&gt;" />.</summary> 332public static Vector512<float> AsSingle<T>(this Vector512<T> vector) => vector.As<T, float>(); 334/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UInt16&gt;" />.</summary> 341public static Vector512<ushort> AsUInt16<T>(this Vector512<T> vector) => vector.As<T, ushort>(); 343/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UInt32&gt;" />.</summary> 350public static Vector512<uint> AsUInt32<T>(this Vector512<T> vector) => vector.As<T, uint>(); 352/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UInt64&gt;" />.</summary> 359public static Vector512<ulong> AsUInt64<T>(this Vector512<T> vector) => vector.As<T, ulong>(); 361/// <summary>Reinterprets a <see cref="Vector{T}" /> as a new <see cref="Vector512{T}" />.</summary> 364/// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector512{T}" />.</returns> 368public static Vector512<T> AsVector512<T>(this Vector<T> value) 370Debug.Assert(Vector512<T>.Count >= Vector<T>.Count); 373Vector512<T> result = default; 374Unsafe.WriteUnaligned(ref Unsafe.As<Vector512<T>, byte>(ref result), value); 378/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see cref="Vector{T}" />.</summary> 385public static Vector<T> AsVector<T>(this Vector512<T> value) 387Debug.Assert(Vector512<T>.Count >= Vector<T>.Count); 390ref byte address = ref Unsafe.As<Vector512<T>, byte>(ref value); 401public static Vector512<T> BitwiseAnd<T>(Vector512<T> left, Vector512<T> right) => left & right; 410public static Vector512<T> BitwiseOr<T>(Vector512<T> left, Vector512<T> right) => left | right; 417internal static Vector512<T> Ceiling<T>(Vector512<T> vector) 438public static Vector512<float> Ceiling(Vector512<float> vector) => Ceiling<float>(vector); 445public static Vector512<double> Ceiling(Vector512<double> vector) => Ceiling<double>(vector); 449public static Vector512<T> Clamp<T>(Vector512<T> value, Vector512<T> min, Vector512<T> max) 457public static Vector512<T> ClampNative<T>(Vector512<T> value, Vector512<T> min, Vector512<T> max) 473public static Vector512<T> ConditionalSelect<T>(Vector512<T> condition, Vector512<T> left, Vector512<T> right) => (left & condition) | AndNot(right, condition); 480public static Vector512<double> ConvertToDouble(Vector512<long> vector) 494public static Vector512<double> ConvertToDouble(Vector512<ulong> vector) 507public static Vector512<int> ConvertToInt32(Vector512<float> vector) 520public static Vector512<int> ConvertToInt32Native(Vector512<float> vector) 533public static Vector512<long> ConvertToInt64(Vector512<double> vector) 546public static Vector512<long> ConvertToInt64Native(Vector512<double> vector) 559public static Vector512<float> ConvertToSingle(Vector512<int> vector) 573public static Vector512<float> ConvertToSingle(Vector512<uint> vector) 587public static Vector512<uint> ConvertToUInt32(Vector512<float> vector) 601public static Vector512<uint> ConvertToUInt32Native(Vector512<float> vector) 615public static Vector512<ulong> ConvertToUInt64(Vector512<double> vector) 629public static Vector512<ulong> ConvertToUInt64Native(Vector512<double> vector) 640public static Vector512<T> CopySign<T>(Vector512<T> value, Vector512<T> sign) 648return VectorMath.CopySign<Vector512<T>, T>(value, sign); 659/// <summary>Copies a <see cref="Vector512{T}" /> to a given array.</summary> 663/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</exception> 666public static void CopyTo<T>(this Vector512<T> vector, T[] destination) 670if (destination.Length < Vector512<T>.Count) 678/// <summary>Copies a <see cref="Vector512{T}" /> to a given array starting at the specified index.</summary> 683/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</exception> 687public static void CopyTo<T>(this Vector512<T> vector, T[] destination, int startIndex) 696if ((destination.Length - startIndex) < Vector512<T>.Count) 704/// <summary>Copies a <see cref="Vector512{T}" /> to a given span.</summary> 708/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</exception> 710public static void CopyTo<T>(this Vector512<T> vector, Span<T> destination) 712if (destination.Length < Vector512<T>.Count) 722public static Vector512<double> Asin(Vector512<double> vector) 726return VectorMath.AsinDouble<Vector512<double>, Vector512<ulong>>(vector); 739public static Vector512<float> Asin(Vector512<float> vector) 743return VectorMath.AsinSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 756public static Vector512<double> Cos(Vector512<double> vector) 760return VectorMath.CosDouble<Vector512<double>, Vector512<long>>(vector); 773public static Vector512<float> Cos(Vector512<float> vector) 777return VectorMath.CosSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 791public static int Count<T>(Vector512<T> vector, T value) => CountMatches(Equals(vector, Create(value))); 796public static int CountWhereAllBitsSet<T>(Vector512<T> vector) 812/// <summary>Creates a new <see cref="Vector512{T}" /> instance with all elements initialized to the specified value.</summary> 815/// <returns>A new <see cref="Vector512{T}" /> with all elements initialized to <paramref name="value" />.</returns> 818public static Vector512<T> Create<T>(T value) 829public static Vector512<byte> Create(byte value) => Create<byte>(value); 836public static Vector512<double> Create(double value) => Create<double>(value); 843public static Vector512<short> Create(short value) => Create<short>(value); 850public static Vector512<int> Create(int value) => Create<int>(value); 857public static Vector512<long> Create(long value) => Create<long>(value); 863public static Vector512<nint> Create(nint value) => Create<nint>(value); 870public static Vector512<nuint> Create(nuint value) => Create<nuint>(value); 878public static Vector512<sbyte> Create(sbyte value) => Create<sbyte>(value); 885public static Vector512<float> Create(float value) => Create<float>(value); 893public static Vector512<ushort> Create(ushort value) => Create<ushort>(value); 901public static Vector512<uint> Create(uint value) => Create<uint>(value); 909public static Vector512<ulong> Create(ulong value) => Create<ulong>(value); 911/// <summary>Creates a new <see cref="Vector512{T}" /> from a given array.</summary> 914/// <returns>A new <see cref="Vector512{T}" /> with its elements set to the first <see cref="Vector512{T}.Count" /> elements from <paramref name="values" />.</returns> 915/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" /> is less than <see cref="Vector512{T}.Count" />.</exception> 918public static Vector512<T> Create<T>(T[] values) 922if (values.Length < Vector512<T>.Count) 927return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref values[0])); 930/// <summary>Creates a new <see cref="Vector512{T}" /> from a given array.</summary> 934/// <returns>A new <see cref="Vector512{T}" /> with its elements set to the first <see cref="Vector256{T}.Count" /> elements from <paramref name="values" />.</returns> 935/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" />, starting from <paramref name="index" />, is less than <see cref="Vector512{T}.Count" />.</exception> 938public static Vector512<T> Create<T>(T[] values, int index) 942if ((index < 0) || ((values.Length - index) < Vector512<T>.Count)) 947return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref values[index])); 950/// <summary>Creates a new <see cref="Vector512{T}" /> from a given readonly span.</summary> 953/// <returns>A new <see cref="Vector512{T}" /> with its elements set to the first <see cref="Vector512{T}.Count" /> elements from <paramref name="values" />.</returns> 954/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" /> is less than <see cref="Vector512{T}.Count" />.</exception> 957public static Vector512<T> Create<T>(ReadOnlySpan<T> values) 959if (values.Length < Vector512<T>.Count) 964return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 1036public static Vector512<byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15, 1060public static Vector512<double> Create(double e0, double e1, double e2, double e3, double e4, double e5, double e6, double e7) 1105public static Vector512<short> Create(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7, short e8, short e9, short e10, short e11, short e12, short e13, short e14, short e15, 1135public static Vector512<int> Create(int e0, int e1, int e2, int e3, int e4, int e5, int e6, int e7, int e8, int e9, int e10, int e11, int e12, int e13, int e14, int e15) 1156public static Vector512<long> Create(long e0, long e1, long e2, long e3, long e4, long e5, long e6, long e7) 1234public static Vector512<sbyte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15, 1266public static Vector512<float> Create(float e0, float e1, float e2, float e3, float e4, float e5, float e6, float e7, float e8, float e9, float e10, float e11, float e12, float e13, float e14, float e15) 1312public static Vector512<ushort> Create(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7, ushort e8, ushort e9, ushort e10, ushort e11, ushort e12, ushort e13, ushort e14, ushort e15, 1343public static Vector512<uint> Create(uint e0, uint e1, uint e2, uint e3, uint e4, uint e5, uint e6, uint e7, uint e8, uint e9, uint e10, uint e11, uint e12, uint e13, uint e14, uint e15) 1365public static Vector512<ulong> Create(ulong e0, ulong e1, ulong e2, ulong e3, ulong e4, ulong e5, ulong e6, ulong e7) 1373/// <summary>Creates a new <see cref="Vector512{T}" /> instance with all 64-bit parts initialized to a specified value.</summary> 1379public static Vector512<T> Create<T>(Vector64<T> value) => Create(Vector128.Create(value, value)); 1381/// <summary>Creates a new <see cref="Vector512{T}" /> instance with all 128-bit parts initialized to a specified value.</summary> 1387public static Vector512<T> Create<T>(Vector128<T> value) => Create(Vector256.Create(value, value)); 1389/// <summary>Creates a new <see cref="Vector512{T}" /> instance with the lower and upper 256-bits initialized to a specified value.</summary> 1395public static Vector512<T> Create<T>(Vector256<T> value) => Create(value, value); 1397/// <summary>Creates a new <see cref="Vector512{T}" /> instance from two <see cref="Vector256{T}" /> instances.</summary> 1401/// <returns>A new <see cref="Vector512{T}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns> 1404public static Vector512<T> Create<T>(Vector256<T> lower, Vector256<T> upper) 1407Unsafe.SkipInit(out Vector512<T> result); 1419public static Vector512<byte> Create(Vector256<byte> lower, Vector256<byte> upper) => Create<byte>(lower, upper); 1426public static Vector512<double> Create(Vector256<double> lower, Vector256<double> upper) => Create<double>(lower, upper); 1432public static Vector512<short> Create(Vector256<short> lower, Vector256<short> upper) => Create<short>(lower, upper); 1439public static Vector512<int> Create(Vector256<int> lower, Vector256<int> upper) => Create<int>(lower, upper); 1445public static Vector512<long> Create(Vector256<long> lower, Vector256<long> upper) => Create<long>(lower, upper); 1451public static Vector512<nint> Create(Vector256<nint> lower, Vector256<nint> upper) => Create<nint>(lower, upper); 1458public static Vector512<nuint> Create(Vector256<nuint> lower, Vector256<nuint> upper) => Create<nuint>(lower, upper); 1465public static Vector512<sbyte> Create(Vector256<sbyte> lower, Vector256<sbyte> upper) => Create<sbyte>(lower, upper); 1472public static Vector512<float> Create(Vector256<float> lower, Vector256<float> upper) => Create<float>(lower, upper); 1479public static Vector512<ushort> Create(Vector256<ushort> lower, Vector256<ushort> upper) => Create<ushort>(lower, upper); 1487public static Vector512<uint> Create(Vector256<uint> lower, Vector256<uint> upper) => Create<uint>(lower, upper); 1494public static Vector512<ulong> Create(Vector256<ulong> lower, Vector256<ulong> upper) => Create<ulong>(lower, upper); 1496/// <summary>Creates a new <see cref="Vector512{T}" /> instance with the first element initialized to the specified value and the remaining elements initialized to zero.</summary> 1499/// <returns>A new <see cref="Vector512{T}" /> instance with the first element initialized to <paramref name="value" /> and the remaining elements initialized to zero.</returns> 1502public static Vector512<T> CreateScalar<T>(T value) => Vector256.CreateScalar(value).ToVector512(); 1508public static Vector512<byte> CreateScalar(byte value) => CreateScalar<byte>(value); 1514public static Vector512<double> CreateScalar(double value) => CreateScalar<double>(value); 1520public static Vector512<short> CreateScalar(short value) => CreateScalar<short>(value); 1526public static Vector512<int> CreateScalar(int value) => CreateScalar<int>(value); 1532public static Vector512<long> CreateScalar(long value) => CreateScalar<long>(value); 1538public static Vector512<nint> CreateScalar(nint value) => CreateScalar<nint>(value); 1545public static Vector512<nuint> CreateScalar(nuint value) => CreateScalar<nuint>(value); 1552public static Vector512<sbyte> CreateScalar(sbyte value) => CreateScalar<sbyte>(value); 1558public static Vector512<float> CreateScalar(float value) => CreateScalar<float>(value); 1565public static Vector512<ushort> CreateScalar(ushort value) => CreateScalar<ushort>(value); 1572public static Vector512<uint> CreateScalar(uint value) => CreateScalar<uint>(value); 1579public static Vector512<ulong> CreateScalar(ulong value) => CreateScalar<ulong>(value); 1581/// <summary>Creates a new <see cref="Vector512{T}" /> instance with the first element initialized to the specified value and the remaining elements left uninitialized.</summary> 1584/// <returns>A new <see cref="Vector512{T}" /> instance with the first element initialized to <paramref name="value" /> and the remaining elements left uninitialized.</returns> 1588public static Vector512<T> CreateScalarUnsafe<T>(T value) 1594Unsafe.SkipInit(out Vector512<T> result); 1604public static Vector512<byte> CreateScalarUnsafe(byte value) => CreateScalarUnsafe<byte>(value); 1610public static Vector512<double> CreateScalarUnsafe(double value) => CreateScalarUnsafe<double>(value); 1616public static Vector512<short> CreateScalarUnsafe(short value) => CreateScalarUnsafe<short>(value); 1622public static Vector512<int> CreateScalarUnsafe(int value) => CreateScalarUnsafe<int>(value); 1628public static Vector512<long> CreateScalarUnsafe(long value) => CreateScalarUnsafe<long>(value); 1634public static Vector512<nint> CreateScalarUnsafe(nint value) => CreateScalarUnsafe<nint>(value); 1641public static Vector512<nuint> CreateScalarUnsafe(nuint value) => CreateScalarUnsafe<nuint>(value); 1648public static Vector512<sbyte> CreateScalarUnsafe(sbyte value) => CreateScalarUnsafe<sbyte>(value); 1654public static Vector512<float> CreateScalarUnsafe(float value) => CreateScalarUnsafe<float>(value); 1661public static Vector512<ushort> CreateScalarUnsafe(ushort value) => CreateScalarUnsafe<ushort>(value); 1668public static Vector512<uint> CreateScalarUnsafe(uint value) => CreateScalarUnsafe<uint>(value); 1675public static Vector512<ulong> CreateScalarUnsafe(ulong value) => CreateScalarUnsafe<ulong>(value); 1677/// <summary>Creates a new <see cref="Vector512{T}" /> instance where the elements begin at a specified value and which are spaced apart according to another specified value.</summary> 1681/// <returns>A new <see cref="Vector512{T}" /> instance with the first element initialized to <paramref name="start" /> and each subsequent element initialized to the value of the previous element plus <paramref name="step" />.</returns> 1684public static Vector512<T> CreateSequence<T>(T start, T step) => (Vector512<T>.Indices * step) + Create(start); 1686/// <summary>Creates a new <see cref="Vector512{T}" /> instance where the elements begin at a specified value and are multiplied by another specified value.</summary> 1690/// <returns>A new <see cref="Vector512{T}" /> instance with each element initialized to <paramref name="initial" /> multiplied by <paramref name="multiplier" /> raised to the element index.</returns> 1694public static Vector512<T> CreateGeometricSequence<T>(T initial, [ConstantExpected] T multiplier) 1696Unsafe.SkipInit(out Vector512<T> result); 1700for (int index = 0; index < Vector512<T>.Count; index++) 1712for (int index = 1; index < Vector512<T>.Count; index++) 1721/// <summary>Creates a new <see cref="Vector512{T}" /> instance whose elements alternate between two specified values.</summary> 1725/// <returns>A new <see cref="Vector512{T}" /> instance whose even-indexed elements are initialized to <paramref name="even" /> and odd-indexed elements are initialized to <paramref name="odd" />.</returns> 1729public static Vector512<T> CreateAlternatingSequence<T>(T even, T odd) 1735/// <summary>Creates a new <see cref="Vector512{T}" /> instance whose elements are the reciprocal of an arithmetic sequence.</summary> 1739/// <returns>A new <see cref="Vector512{T}" /> instance whose elements are initialized to one divided by the corresponding element of the arithmetic sequence.</returns> 1743public static Vector512<T> CreateHarmonicSequence<T>(T start, T step) 1747return Vector512<T>.One / CreateSequence(start, step); 1761public static Vector512<T> ConcatLowerLower<T>(Vector512<T> left, Vector512<T> right) => Create(left.GetLower(), right.GetLower()); 1766public static Vector512<T> ConcatUpperLower<T>(Vector512<T> left, Vector512<T> right) => Create(left.GetUpper(), right.GetLower()); 1771public static Vector512<T> ConcatUpperUpper<T>(Vector512<T> left, Vector512<T> right) => Create(left.GetUpper(), right.GetUpper()); 1776public static Vector512<T> ConcatLowerUpper<T>(Vector512<T> left, Vector512<T> right) => Create(left.GetLower(), right.GetUpper()); 1781public static Vector512<T> ZipLower<T>(Vector512<T> left, Vector512<T> right) => Create( 1789public static Vector512<T> ZipUpper<T>(Vector512<T> left, Vector512<T> right) => Create( 1797public static (Vector512<T> Lower, Vector512<T> Upper) Zip<T>(Vector512<T> left, Vector512<T> right) 1801Vector512<int> lower = Avx512F.UnpackLow(left.AsInt32(), right.AsInt32()); 1802Vector512<int> upper = Avx512F.UnpackHigh(left.AsInt32(), right.AsInt32()); 1804Vector512<int> lowerResult = Avx512F.Shuffle4x128(lower, upper, 0x44); 1807Vector512<int> upperResult = Avx512F.Shuffle4x128(lower, upper, 0xEE); 1827public static Vector512<T> UnzipEven<T>(Vector512<T> left, Vector512<T> right) => Create( 1835public static Vector512<T> UnzipOdd<T>(Vector512<T> left, Vector512<T> right) => Create( 1843public static (Vector512<T> Even, Vector512<T> Odd) Unzip<T>(Vector512<T> left, Vector512<T> right) 1847Vector512<int> evenIndices = Create( 1851Vector512<int> oddIndices = Create( 1856Vector512<int> even = Avx512F.PermuteVar16x32x2(left.AsInt32(), evenIndices, right.AsInt32()); 1857Vector512<int> odd = Avx512F.PermuteVar16x32x2(left.AsInt32(), oddIndices, right.AsInt32()); 1876public static Vector512<T> Reverse<T>(Vector512<T> vector) => Create( 1884public static Vector512<double> DegreesToRadians(Vector512<double> degrees) 1888return VectorMath.DegreesToRadiansDouble<Vector512<double>, Vector512<ulong>>(degrees); 1902public static Vector512<float> DegreesToRadians(Vector512<float> degrees) 1906return VectorMath.DegreesToRadiansSingle<Vector512<float>, Vector512<double>>(degrees); 1925public static Vector512<T> Divide<T>(Vector512<T> left, Vector512<T> right) => left / right; 1933public static Vector512<T> Divide<T>(Vector512<T> left, T right) => left / right; 1943public static T Dot<T>(Vector512<T> left, Vector512<T> right) => Sum(left * right); 1953public static Vector512<T> Equals<T>(Vector512<T> left, Vector512<T> right) 1968public static bool EqualsAll<T>(Vector512<T> left, Vector512<T> right) => left == right; 1978public static bool EqualsAny<T>(Vector512<T> left, Vector512<T> right) 1986public static Vector512<double> Exp(Vector512<double> vector) 1990return VectorMath.ExpDouble<Vector512<double>, Vector512<ulong>>(vector); 2003public static Vector512<float> Exp(Vector512<float> vector) 2007return VectorMath.ExpSingle<Vector512<float>, Vector512<uint>, Vector512<double>, Vector512<ulong>>(vector); 2026public static ulong ExtractMostSignificantBits<T>(this Vector512<T> vector) 2038internal static Vector512<T> Floor<T>(Vector512<T> vector) 2059public static Vector512<float> Floor(Vector512<float> vector) => Floor<float>(vector); 2066public static Vector512<double> Floor(Vector512<double> vector) => Floor<double>(vector); 2071public static Vector512<double> FusedMultiplyAdd(Vector512<double> left, Vector512<double> right, Vector512<double> addend) 2082public static Vector512<float> FusedMultiplyAdd(Vector512<float> left, Vector512<float> right, Vector512<float> addend) 2099public static T GetElement<T>(this Vector512<T> vector, int index) 2101if ((uint)(index) >= (uint)(Vector512<T>.Count)) 2115public static Vector256<T> GetLower<T>(this Vector512<T> vector) 2127public static Vector256<T> GetUpper<T>(this Vector512<T> vector) 2141public static Vector512<T> GreaterThan<T>(Vector512<T> left, Vector512<T> right) 2157public static bool GreaterThanAll<T>(Vector512<T> left, Vector512<T> right) 2171public static bool GreaterThanAny<T>(Vector512<T> left, Vector512<T> right) 2185public static Vector512<T> GreaterThanOrEqual<T>(Vector512<T> left, Vector512<T> right) 2201public static bool GreaterThanOrEqualAll<T>(Vector512<T> left, Vector512<T> right) 2215public static bool GreaterThanOrEqualAny<T>(Vector512<T> left, Vector512<T> right) 2223public static Vector512<double> Hypot(Vector512<double> x, Vector512<double> y) 2227return VectorMath.HypotDouble<Vector512<double>, Vector512<ulong>>(x, y); 2240public static Vector512<float> Hypot(Vector512<float> x, Vector512<float> y) 2244return VectorMath.HypotSingle<Vector512<float>, Vector512<double>>(x, y); 2258public static int IndexOf<T>(Vector512<T> vector, T value) => IndexOfFirstMatch(Equals(vector, Create(value))); 2263public static int IndexOfWhereAllBitsSet<T>(Vector512<T> vector) 2282public static Vector512<T> IsEvenInteger<T>(Vector512<T> vector) 2286return VectorMath.IsEvenIntegerSingle<Vector512<float>, Vector512<uint>>(vector.AsSingle()).As<float, T>(); 2290return VectorMath.IsEvenIntegerDouble<Vector512<double>, Vector512<ulong>>(vector.AsDouble()).As<double, T>(); 2292return IsZero(vector & Vector512<T>.One); 2298public static Vector512<T> IsFinite<T>(Vector512<T> vector) 2302return ~IsZero(AndNot(Vector512<float>.PositiveInfinity.AsUInt32(), vector.AsUInt32())).As<uint, T>(); 2306return ~IsZero(AndNot(Vector512<double>.PositiveInfinity.AsUInt64(), vector.AsUInt64())).As<ulong, T>(); 2308return Vector512<T>.AllBitsSet; 2314public static Vector512<T> IsInfinity<T>(Vector512<T> vector) 2320return Vector512<T>.Zero; 2326public static Vector512<T> IsInteger<T>(Vector512<T> vector) 2332return Vector512<T>.AllBitsSet; 2338public static Vector512<T> IsNaN<T>(Vector512<T> vector) 2344return Vector512<T>.Zero; 2350public static Vector512<T> IsNegative<T>(Vector512<T> vector) 2354return Vector512<T>.Zero; 2358return LessThan(vector.AsInt32(), Vector512<int>.Zero).As<int, T>(); 2362return LessThan(vector.AsInt64(), Vector512<long>.Zero).As<long, T>(); 2366return LessThan(vector, Vector512<T>.Zero); 2373public static Vector512<T> IsNegativeInfinity<T>(Vector512<T> vector) 2377return Equals(vector, Vector512<float>.NegativeInfinity.As<float, T>()); 2381return Equals(vector, Vector512<double>.NegativeInfinity.As<double, T>()); 2383return Vector512<T>.Zero; 2389public static Vector512<T> IsNormal<T>(Vector512<T> vector) 2405public static Vector512<T> IsOddInteger<T>(Vector512<T> vector) 2409return VectorMath.IsOddIntegerSingle<Vector512<float>, Vector512<uint>>(vector.AsSingle()).As<float, T>(); 2413return VectorMath.IsOddIntegerDouble<Vector512<double>, Vector512<ulong>>(vector.AsDouble()).As<double, T>(); 2415return ~IsZero(vector & Vector512<T>.One); 2421public static Vector512<T> IsPositive<T>(Vector512<T> vector) 2425return Vector512<T>.AllBitsSet; 2429return GreaterThanOrEqual(vector.AsInt32(), Vector512<int>.Zero).As<int, T>(); 2433return GreaterThanOrEqual(vector.AsInt64(), Vector512<long>.Zero).As<long, T>(); 2437return GreaterThanOrEqual(vector, Vector512<T>.Zero); 2444public static Vector512<T> IsPositiveInfinity<T>(Vector512<T> vector) 2448return Equals(vector, Vector512<float>.PositiveInfinity.As<float, T>()); 2452return Equals(vector, Vector512<double>.PositiveInfinity.As<double, T>()); 2454return Vector512<T>.Zero; 2460public static Vector512<T> IsSubnormal<T>(Vector512<T> vector) 2464return LessThan(Abs(vector).AsUInt32() - Vector512<uint>.One, Create<uint>(float.MaxTrailingSignificand)).As<uint, T>(); 2468return LessThan(Abs(vector).AsUInt64() - Vector512<ulong>.One, Create<ulong>(double.MaxTrailingSignificand)).As<ulong, T>(); 2470return Vector512<T>.Zero; 2476public static Vector512<T> IsZero<T>(Vector512<T> vector) => Equals(vector, Vector512<T>.Zero); 2481public static int LastIndexOf<T>(Vector512<T> vector, T value) => IndexOfLastMatch(Equals(vector, Create(value))); 2486public static int LastIndexOfWhereAllBitsSet<T>(Vector512<T> vector) 2505public static Vector512<double> Lerp(Vector512<double> x, Vector512<double> y, Vector512<double> amount) 2509return VectorMath.Lerp<Vector512<double>, double>(x, y, amount); 2523public static Vector512<float> Lerp(Vector512<float> x, Vector512<float> y, Vector512<float> amount) 2527return VectorMath.Lerp<Vector512<float>, float>(x, y, amount); 2546public static Vector512<T> LessThan<T>(Vector512<T> left, Vector512<T> right) 2562public static bool LessThanAll<T>(Vector512<T> left, Vector512<T> right) 2576public static bool LessThanAny<T>(Vector512<T> left, Vector512<T> right) 2590public static Vector512<T> LessThanOrEqual<T>(Vector512<T> left, Vector512<T> right) 2606public static bool LessThanOrEqualAll<T>(Vector512<T> left, Vector512<T> right) 2620public static bool LessThanOrEqualAny<T>(Vector512<T> left, Vector512<T> right) 2633public static unsafe Vector512<T> Load<T>(T* source) => LoadUnsafe(ref *source); 2643public static unsafe Vector512<T> LoadAligned<T>(T* source) 2652return *(Vector512<T>*)(source); 2663public static unsafe Vector512<T> LoadAlignedNonTemporal<T>(T* source) => LoadAligned(source); 2672public static Vector512<T> LoadUnsafe<T>(ref readonly T source) 2676return Unsafe.ReadUnaligned<Vector512<T>>(in address); 2688public static Vector512<T> LoadUnsafe<T>(ref readonly T source, nuint elementOffset) 2692return Unsafe.ReadUnaligned<Vector512<T>>(in address); 2698internal static Vector512<ushort> LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source)); 2704internal static Vector512<ushort> LoadUnsafe(ref char source, nuint elementOffset) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source), elementOffset); 2708public static Vector512<double> Log(Vector512<double> vector) 2712return VectorMath.LogDouble<Vector512<double>, Vector512<long>, Vector512<ulong>>(vector); 2725public static Vector512<float> Log(Vector512<float> vector) 2729return VectorMath.LogSingle<Vector512<float>, Vector512<int>, Vector512<uint>>(vector); 2742public static Vector512<double> Log2(Vector512<double> vector) 2746return VectorMath.Log2Double<Vector512<double>, Vector512<long>, Vector512<ulong>>(vector); 2759public static Vector512<float> Log2(Vector512<float> vector) 2763return VectorMath.Log2Single<Vector512<float>, Vector512<int>, Vector512<uint>>(vector); 2777public static Vector512<T> Max<T>(Vector512<T> left, Vector512<T> right) 2781return VectorMath.Max<Vector512<T>, T>(left, right); 2795public static Vector512<T> MaxMagnitude<T>(Vector512<T> left, Vector512<T> right) 2799return VectorMath.MaxMagnitude<Vector512<T>, T>(left, right); 2813public static Vector512<T> MaxMagnitudeNumber<T>(Vector512<T> left, Vector512<T> right) 2817return VectorMath.MaxMagnitudeNumber<Vector512<T>, T>(left, right); 2831public static Vector512<T> MaxNative<T>(Vector512<T> left, Vector512<T> right) 2849public static Vector512<T> MaxNumber<T>(Vector512<T> left, Vector512<T> right) 2853return VectorMath.MaxNumber<Vector512<T>, T>(left, right); 2867public static Vector512<T> Min<T>(Vector512<T> left, Vector512<T> right) 2871return VectorMath.Min<Vector512<T>, T>(left, right); 2885public static Vector512<T> MinMagnitude<T>(Vector512<T> left, Vector512<T> right) 2889return VectorMath.MinMagnitude<Vector512<T>, T>(left, right); 2903public static Vector512<T> MinMagnitudeNumber<T>(Vector512<T> left, Vector512<T> right) 2907return VectorMath.MinMagnitudeNumber<Vector512<T>, T>(left, right); 2921public static Vector512<T> MinNative<T>(Vector512<T> left, Vector512<T> right) 2939public static Vector512<T> MinNumber<T>(Vector512<T> left, Vector512<T> right) 2943return VectorMath.MinNumber<Vector512<T>, T>(left, right); 2961public static Vector512<T> Multiply<T>(Vector512<T> left, Vector512<T> right) => left * right; 2970public static Vector512<T> Multiply<T>(Vector512<T> left, T right) => left * right; 2979public static Vector512<T> Multiply<T>(T left, Vector512<T> right) => right * left; 2983internal static Vector512<T> MultiplyAddEstimate<T>(Vector512<T> left, Vector512<T> right, Vector512<T> addend) 2994public static Vector512<double> MultiplyAddEstimate(Vector512<double> left, Vector512<double> right, Vector512<double> addend) 3004public static Vector512<float> MultiplyAddEstimate(Vector512<float> left, Vector512<float> right, Vector512<float> addend) 3014internal static Vector512<TResult> Narrow<TSource, TResult>(Vector512<TSource> lower, Vector512<TSource> upper) 3018Unsafe.SkipInit(out Vector512<TResult> result); 3020for (int i = 0; i < Vector512<TSource>.Count; i++) 3026for (int i = Vector512<TSource>.Count; i < Vector512<TResult>.Count; i++) 3028TResult value = TResult.CreateTruncating(upper.GetElementUnsafe(i - Vector512<TSource>.Count)); 3038public static Vector512<float> Narrow(Vector512<double> lower, Vector512<double> upper) 3045public static Vector512<sbyte> Narrow(Vector512<short> lower, Vector512<short> upper) 3051public static Vector512<short> Narrow(Vector512<int> lower, Vector512<int> upper) 3057public static Vector512<int> Narrow(Vector512<long> lower, Vector512<long> upper) 3064public static Vector512<byte> Narrow(Vector512<ushort> lower, Vector512<ushort> upper) 3071public static Vector512<ushort> Narrow(Vector512<uint> lower, Vector512<uint> upper) 3078public static Vector512<uint> Narrow(Vector512<ulong> lower, Vector512<ulong> upper) 3083internal static Vector512<TResult> NarrowWithSaturation<TSource, TResult>(Vector512<TSource> lower, Vector512<TSource> upper) 3087Unsafe.SkipInit(out Vector512<TResult> result); 3089for (int i = 0; i < Vector512<TSource>.Count; i++) 3095for (int i = Vector512<TSource>.Count; i < Vector512<TResult>.Count; i++) 3097TResult value = TResult.CreateSaturating(upper.GetElementUnsafe(i - Vector512<TSource>.Count)); 3107public static Vector512<float> NarrowWithSaturation(Vector512<double> lower, Vector512<double> upper) 3114public static Vector512<sbyte> NarrowWithSaturation(Vector512<short> lower, Vector512<short> upper) 3120public static Vector512<short> NarrowWithSaturation(Vector512<int> lower, Vector512<int> upper) 3126public static Vector512<int> NarrowWithSaturation(Vector512<long> lower, Vector512<long> upper) 3133public static Vector512<byte> NarrowWithSaturation(Vector512<ushort> lower, Vector512<ushort> upper) 3140public static Vector512<ushort> NarrowWithSaturation(Vector512<uint> lower, Vector512<uint> upper) 3147public static Vector512<uint> NarrowWithSaturation(Vector512<ulong> lower, Vector512<ulong> upper) 3156public static Vector512<T> Negate<T>(Vector512<T> vector) => -vector; 3161public static bool None<T>(Vector512<T> vector, T value) => !EqualsAny(vector, Create(value)); 3166public static bool NoneWhereAllBitsSet<T>(Vector512<T> vector) 3188public static Vector512<T> OnesComplement<T>(Vector512<T> vector) => ~vector; 3193public static Vector512<double> RadiansToDegrees(Vector512<double> radians) 3197return VectorMath.RadiansToDegreesDouble<Vector512<double>, Vector512<ulong>>(radians); 3211public static Vector512<float> RadiansToDegrees(Vector512<float> radians) 3215return VectorMath.RadiansToDegreesSingle<Vector512<float>, Vector512<double>>(radians); 3228internal static Vector512<T> Round<T>(Vector512<T> vector) 3246public static Vector512<double> Round(Vector512<double> vector) => Round<double>(vector); 3250public static Vector512<float> Round(Vector512<float> vector) => Round<float>(vector); 3254public static Vector512<double> Round(Vector512<double> vector, MidpointRounding mode) => VectorMath.RoundDouble(vector, mode); 3258public static Vector512<float> Round(Vector512<float> vector, MidpointRounding mode) => VectorMath.RoundSingle(vector, mode); 3265internal static Vector512<T> ShiftLeft<T>(Vector512<T> vector, int shiftCount) => vector << shiftCount; 3272public static Vector512<byte> ShiftLeft(Vector512<byte> vector, int shiftCount) => vector << shiftCount; 3279public static Vector512<short> ShiftLeft(Vector512<short> vector, int shiftCount) => vector << shiftCount; 3286public static Vector512<int> ShiftLeft(Vector512<int> vector, int shiftCount) => vector << shiftCount; 3293public static Vector512<long> ShiftLeft(Vector512<long> vector, int shiftCount) => vector << shiftCount; 3300public static Vector512<nint> ShiftLeft(Vector512<nint> vector, int shiftCount) => vector << shiftCount; 3308public static Vector512<nuint> ShiftLeft(Vector512<nuint> vector, int shiftCount) => vector << shiftCount; 3316public static Vector512<sbyte> ShiftLeft(Vector512<sbyte> vector, int shiftCount) => vector << shiftCount; 3324public static Vector512<ushort> ShiftLeft(Vector512<ushort> vector, int shiftCount) => vector << shiftCount; 3332public static Vector512<uint> ShiftLeft(Vector512<uint> vector, int shiftCount) => vector << shiftCount; 3335internal static Vector512<uint> ShiftLeft(Vector512<uint> vector, Vector512<uint> shiftCount) 3349public static Vector512<ulong> ShiftLeft(Vector512<ulong> vector, int shiftCount) => vector << shiftCount; 3352internal static Vector512<ulong> ShiftLeft(Vector512<ulong> vector, Vector512<ulong> shiftCount) 3365internal static Vector512<T> ShiftRightArithmetic<T>(Vector512<T> vector, int shiftCount) => vector >> shiftCount; 3372public static Vector512<short> ShiftRightArithmetic(Vector512<short> vector, int shiftCount) => vector >> shiftCount; 3379public static Vector512<int> ShiftRightArithmetic(Vector512<int> vector, int shiftCount) => vector >> shiftCount; 3386public static Vector512<long> ShiftRightArithmetic(Vector512<long> vector, int shiftCount) => vector >> shiftCount; 3393public static Vector512<nint> ShiftRightArithmetic(Vector512<nint> vector, int shiftCount) => vector >> shiftCount; 3401public static Vector512<sbyte> ShiftRightArithmetic(Vector512<sbyte> vector, int shiftCount) => vector >> shiftCount; 3408internal static Vector512<T> ShiftRightLogical<T>(Vector512<T> vector, int shiftCount) => vector >>> shiftCount; 3415public static Vector512<byte> ShiftRightLogical(Vector512<byte> vector, int shiftCount) => vector >>> shiftCount; 3422public static Vector512<short> ShiftRightLogical(Vector512<short> vector, int shiftCount) => vector >>> shiftCount; 3429public static Vector512<int> ShiftRightLogical(Vector512<int> vector, int shiftCount) => vector >>> shiftCount; 3436public static Vector512<long> ShiftRightLogical(Vector512<long> vector, int shiftCount) => vector >>> shiftCount; 3443public static Vector512<nint> ShiftRightLogical(Vector512<nint> vector, int shiftCount) => vector >>> shiftCount; 3451public static Vector512<nuint> ShiftRightLogical(Vector512<nuint> vector, int shiftCount) => vector >>> shiftCount; 3459public static Vector512<sbyte> ShiftRightLogical(Vector512<sbyte> vector, int shiftCount) => vector >>> shiftCount; 3467public static Vector512<ushort> ShiftRightLogical(Vector512<ushort> vector, int shiftCount) => vector >>> shiftCount; 3475public static Vector512<uint> ShiftRightLogical(Vector512<uint> vector, int shiftCount) => vector >>> shiftCount; 3483public static Vector512<ulong> ShiftRightLogical(Vector512<ulong> vector, int shiftCount) => vector >>> shiftCount; 3485private static Vector512<T> ShuffleFallback<T, TIndex>(Vector512<T> vector, Vector512<TIndex> indices) 3488Debug.Assert(Vector512<T>.Count == Vector512<TIndex>.Count); 3489Vector512<T> result = Vector512<T>.Zero; 3491for (int index = 0; index < Vector512<T>.Count; index++) 3495if ((uint)selectedIndex < (uint)Vector512<T>.Count) 3509private static Vector512<T> ShuffleNativeFallback<T, TIndex>(Vector512<T> vector, Vector512<TIndex> indices) 3520public static Vector512<byte> Shuffle(Vector512<byte> vector, Vector512<byte> indices) => ShuffleFallback(vector, indices); 3522/// <inheritdoc cref="Shuffle(Vector512{byte}, Vector512{byte})" /> 3524public static Vector512<double> Shuffle(Vector512<double> vector, Vector512<long> indices) => ShuffleFallback(vector, indices); 3526/// <inheritdoc cref="Shuffle(Vector512{byte}, Vector512{byte})" /> 3528public static Vector512<short> Shuffle(Vector512<short> vector, Vector512<short> indices) => ShuffleFallback(vector, indices); 3530/// <inheritdoc cref="Shuffle(Vector512{byte}, Vector512{byte})" /> 3532public static Vector512<int> Shuffle(Vector512<int> vector, Vector512<int> indices) => ShuffleFallback(vector, indices); 3534/// <inheritdoc cref="Shuffle(Vector512{byte}, Vector512{byte})" /> 3536public static Vector512<long> Shuffle(Vector512<long> vector, Vector512<long> indices) => ShuffleFallback(vector, indices); 3538/// <inheritdoc cref="Shuffle(Vector512{byte}, Vector512{byte})" /> 3540public static Vector512<nint> Shuffle(Vector512<nint> vector, Vector512<nint> indices) => ShuffleFallback(vector, indices); 3542/// <inheritdoc cref="Shuffle(Vector512{byte}, Vector512{byte})" /> 3545public static Vector512<sbyte> Shuffle(Vector512<sbyte> vector, Vector512<sbyte> indices) => ShuffleFallback(vector, indices); 3547/// <inheritdoc cref="Shuffle(Vector512{byte}, Vector512{byte})" /> 3549public static Vector512<float> Shuffle(Vector512<float> vector, Vector512<int> indices) => ShuffleFallback(vector, indices); 3551/// <inheritdoc cref="Shuffle(Vector512{byte}, Vector512{byte})" /> 3554public static Vector512<ushort> Shuffle(Vector512<ushort> vector, Vector512<ushort> indices) => ShuffleFallback(vector, indices); 3556/// <inheritdoc cref="Shuffle(Vector512{byte}, Vector512{byte})" /> 3559public static Vector512<uint> Shuffle(Vector512<uint> vector, Vector512<uint> indices) => ShuffleFallback(vector, indices); 3561/// <inheritdoc cref="Shuffle(Vector512{byte}, Vector512{byte})" /> 3564public static Vector512<ulong> Shuffle(Vector512<ulong> vector, Vector512<ulong> indices) => ShuffleFallback(vector, indices); 3566/// <inheritdoc cref="Shuffle(Vector512{byte}, Vector512{byte})" /> 3569public static Vector512<nuint> Shuffle(Vector512<nuint> vector, Vector512<nuint> indices) => ShuffleFallback(vector, indices); 3578public static Vector512<byte> ShuffleNative(Vector512<byte> vector, Vector512<byte> indices) => ShuffleNativeFallback(vector, indices); 3580/// <inheritdoc cref="ShuffleNative(Vector512{byte}, Vector512{byte})" /> 3583public static Vector512<double> ShuffleNative(Vector512<double> vector, Vector512<long> indices) => ShuffleNativeFallback(vector, indices); 3585/// <inheritdoc cref="ShuffleNative(Vector512{byte}, Vector512{byte})" /> 3588public static Vector512<short> ShuffleNative(Vector512<short> vector, Vector512<short> indices) => ShuffleNativeFallback(vector, indices); 3590/// <inheritdoc cref="ShuffleNative(Vector512{byte}, Vector512{byte})" /> 3593public static Vector512<int> ShuffleNative(Vector512<int> vector, Vector512<int> indices) => ShuffleNativeFallback(vector, indices); 3595/// <inheritdoc cref="ShuffleNative(Vector512{byte}, Vector512{byte})" /> 3598public static Vector512<long> ShuffleNative(Vector512<long> vector, Vector512<long> indices) => ShuffleNativeFallback(vector, indices); 3600/// <inheritdoc cref="ShuffleNative(Vector512{byte}, Vector512{byte})" /> 3603public static Vector512<nint> ShuffleNative(Vector512<nint> vector, Vector512<nint> indices) => ShuffleNativeFallback(vector, indices); 3605/// <inheritdoc cref="ShuffleNative(Vector512{byte}, Vector512{byte})" /> 3609public static Vector512<sbyte> ShuffleNative(Vector512<sbyte> vector, Vector512<sbyte> indices) => ShuffleNativeFallback(vector, indices); 3611/// <inheritdoc cref="ShuffleNative(Vector512{byte}, Vector512{byte})" /> 3614public static Vector512<float> ShuffleNative(Vector512<float> vector, Vector512<int> indices) => ShuffleNativeFallback(vector, indices); 3616/// <inheritdoc cref="ShuffleNative(Vector512{byte}, Vector512{byte})" /> 3620public static Vector512<ushort> ShuffleNative(Vector512<ushort> vector, Vector512<ushort> indices) => ShuffleNativeFallback(vector, indices); 3622/// <inheritdoc cref="ShuffleNative(Vector512{byte}, Vector512{byte})" /> 3626public static Vector512<uint> ShuffleNative(Vector512<uint> vector, Vector512<uint> indices) => ShuffleNativeFallback(vector, indices); 3628/// <inheritdoc cref="ShuffleNative(Vector512{byte}, Vector512{byte})" /> 3632public static Vector512<ulong> ShuffleNative(Vector512<ulong> vector, Vector512<ulong> indices) => ShuffleNativeFallback(vector, indices); 3634/// <inheritdoc cref="ShuffleNative(Vector512{byte}, Vector512{byte})" /> 3638public static Vector512<nuint> ShuffleNative(Vector512<nuint> vector, Vector512<nuint> indices) => ShuffleNativeFallback(vector, indices); 3642public static Vector512<double> Sin(Vector512<double> vector) 3646return VectorMath.SinDouble<Vector512<double>, Vector512<long>>(vector); 3659public static Vector512<float> Sin(Vector512<float> vector) 3663return VectorMath.SinSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 3676public static (Vector512<double> Sin, Vector512<double> Cos) SinCos(Vector512<double> vector) 3680return VectorMath.SinCosDouble<Vector512<double>, Vector512<long>>(vector); 3696public static (Vector512<float> Sin, Vector512<float> Cos) SinCos(Vector512<float> vector) 3700return VectorMath.SinCosSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 3721public static Vector512<T> Sqrt<T>(Vector512<T> vector) 3736public static unsafe void Store<T>(this Vector512<T> source, T* destination) => source.StoreUnsafe(ref *destination); 3746public static unsafe void StoreAligned<T>(this Vector512<T> source, T* destination) 3755*(Vector512<T>*)(destination) = source; 3766public static unsafe void StoreAlignedNonTemporal<T>(this Vector512<T> source, T* destination) => source.StoreAligned(destination); 3775public static void StoreUnsafe<T>(this Vector512<T> source, ref T destination) 3791public static void StoreUnsafe<T>(this Vector512<T> source, ref T destination, nuint elementOffset) 3800public static Vector512<T> Subtract<T>(Vector512<T> left, Vector512<T> right) => left - right; 3805public static Vector512<T> SubtractSaturate<T>(Vector512<T> left, Vector512<T> right) 3827public static T Sum<T>(Vector512<T> vector) 3844public static T ToScalar<T>(this Vector512<T> vector) 3852internal static Vector512<T> Truncate<T>(Vector512<T> vector) 3870public static Vector512<double> Truncate(Vector512<double> vector) => Truncate<double>(vector); 3874public static Vector512<float> Truncate(Vector512<float> vector) => Truncate<float>(vector); 3880/// <returns><c>true</c> if <paramref name="vector" /> was successfully copied to <paramref name="destination" />; otherwise, <c>false</c> if the length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</returns> 3882public static bool TryCopyTo<T>(this Vector512<T> vector, Span<T> destination) 3884if (destination.Length < Vector512<T>.Count) 3893/// <summary>Widens a <see langword="Vector512&lt;Byte&gt;" /> into two <see cref="Vector512{UInt16} " />.</summary> 3898public static (Vector512<ushort> Lower, Vector512<ushort> Upper) Widen(Vector512<byte> source) => (WidenLower(source), WidenUpper(source)); 3900/// <summary>Widens a <see langword="Vector512&lt;Int16&gt;" /> into two <see cref="Vector512{Int32} " />.</summary> 3904public static (Vector512<int> Lower, Vector512<int> Upper) Widen(Vector512<short> source) => (WidenLower(source), WidenUpper(source)); 3906/// <summary>Widens a <see langword="Vector512&lt;Int32&gt;" /> into two <see cref="Vector512{Int64} " />.</summary> 3910public static (Vector512<long> Lower, Vector512<long> Upper) Widen(Vector512<int> source) => (WidenLower(source), WidenUpper(source)); 3912/// <summary>Widens a <see langword="Vector512&lt;SByte&gt;" /> into two <see cref="Vector512{Int16} " />.</summary> 3917public static (Vector512<short> Lower, Vector512<short> Upper) Widen(Vector512<sbyte> source) => (WidenLower(source), WidenUpper(source)); 3919/// <summary>Widens a <see langword="Vector512&lt;Single&gt;" /> into two <see cref="Vector512{Double} " />.</summary> 3923public static (Vector512<double> Lower, Vector512<double> Upper) Widen(Vector512<float> source) => (WidenLower(source), WidenUpper(source)); 3925/// <summary>Widens a <see langword="Vector512&lt;UInt16&gt;" /> into two <see cref="Vector512{UInt32} " />.</summary> 3930public static (Vector512<uint> Lower, Vector512<uint> Upper) Widen(Vector512<ushort> source) => (WidenLower(source), WidenUpper(source)); 3932/// <summary>Widens a <see langword="Vector512&lt;UInt32&gt;" /> into two <see cref="Vector512{UInt64} " />.</summary> 3937public static (Vector512<ulong> Lower, Vector512<ulong> Upper) Widen(Vector512<uint> source) => (WidenLower(source), WidenUpper(source)); 3939/// <summary>Widens the lower half of a <see langword="Vector512&lt;Byte&gt;" /> into a <see cref="Vector512{UInt16} " />.</summary> 3945public static Vector512<ushort> WidenLower(Vector512<byte> source) 3955/// <summary>Widens the lower half of a <see langword="Vector512&lt;Int16&gt;" /> into a <see cref="Vector512{Int32} " />.</summary> 3960public static Vector512<int> WidenLower(Vector512<short> source) 3970/// <summary>Widens the lower half of a <see langword="Vector512&lt;Int32&gt;" /> into a <see cref="Vector512{Int64} " />.</summary> 3975public static Vector512<long> WidenLower(Vector512<int> source) 3985/// <summary>Widens the lower half of a <see langword="Vector512&lt;SByte&gt;" /> into a <see cref="Vector512{Int16} " />.</summary> 3991public static Vector512<short> WidenLower(Vector512<sbyte> source) 4000/// <summary>Widens the lower half of a <see langword="Vector512&lt;Single&gt;" /> into a <see cref="Vector512{Double} " />.</summary> 4005public static Vector512<double> WidenLower(Vector512<float> source) 4015/// <summary>Widens the lower half of a <see langword="Vector512&lt;UInt16&gt;" /> into a <see cref="Vector512{UInt32} " />.</summary> 4021public static Vector512<uint> WidenLower(Vector512<ushort> source) 4031/// <summary>Widens the lower half of a <see langword="Vector512&lt;UInt32&gt;" /> into a <see cref="Vector512{UInt64} " />.</summary> 4037public static Vector512<ulong> WidenLower(Vector512<uint> source) 4047/// <summary>Widens the upper half of a <see langword="Vector512&lt;Byte&gt;" /> into a <see cref="Vector512{UInt16} " />.</summary> 4053public static Vector512<ushort> WidenUpper(Vector512<byte> source) 4063/// <summary>Widens the upper half of a <see langword="Vector512&lt;Int16&gt;" /> into a <see cref="Vector512{Int32} " />.</summary> 4068public static Vector512<int> WidenUpper(Vector512<short> source) 4078/// <summary>Widens the upper half of a <see langword="Vector512&lt;Int32&gt;" /> into a <see cref="Vector512{Int64} " />.</summary> 4083public static Vector512<long> WidenUpper(Vector512<int> source) 4093/// <summary>Widens the upper half of a <see langword="Vector512&lt;SByte&gt;" /> into a <see cref="Vector512{Int16} " />.</summary> 4099public static Vector512<short> WidenUpper(Vector512<sbyte> source) 4109/// <summary>Widens the upper half of a <see langword="Vector512&lt;Single&gt;" /> into a <see cref="Vector512{Double} " />.</summary> 4114public static Vector512<double> WidenUpper(Vector512<float> source) 4124/// <summary>Widens the upper half of a <see langword="Vector512&lt;UInt16&gt;" /> into a <see cref="Vector512{UInt32} " />.</summary> 4130public static Vector512<uint> WidenUpper(Vector512<ushort> source) 4140/// <summary>Widens the upper half of a <see langword="Vector512&lt;UInt32&gt;" /> into a <see cref="Vector512{UInt64} " />.</summary> 4146public static Vector512<ulong> WidenUpper(Vector512<uint> source) 4156/// <summary>Creates a new <see cref="Vector512{T}" /> with the element at the specified index set to the specified value and the remaining elements set to the same value as that in the given vector.</summary> 4161/// <returns>A <see cref="Vector512{T}" /> with the value of the element at <paramref name="index" /> set to <paramref name="value" /> and the remaining elements set to the same value as that in <paramref name="vector" />.</returns> 4165public static Vector512<T> WithElement<T>(this Vector512<T> vector, int index, T value) 4167if ((uint)(index) >= (uint)(Vector512<T>.Count)) 4172Vector512<T> result = vector; 4177/// <summary>Creates a new <see cref="Vector512{T}" /> with the lower 256-bits set to the specified value and the upper 256-bits set to the same value as that in the given vector.</summary> 4181/// <returns>A new <see cref="Vector512{T}" /> with the lower 256-bits set to <paramref name="value" /> and the upper 256-bits set to the same value as that in <paramref name="vector" />.</returns> 4185public static Vector512<T> WithLower<T>(this Vector512<T> vector, Vector256<T> value) 4189Vector512<T> result = vector; 4194/// <summary>Creates a new <see cref="Vector512{T}" /> with the upper 256-bits set to the specified value and the lower 256-bits set to the same value as that in the given vector.</summary> 4198/// <returns>A new <see cref="Vector512{T}" /> with the upper 256-bits set to <paramref name="value" /> and the lower 256-bits set to the same value as that in <paramref name="vector" />.</returns> 4202public static Vector512<T> WithUpper<T>(this Vector512<T> vector, Vector256<T> value) 4206Vector512<T> result = vector; 4218public static Vector512<T> Xor<T>(Vector512<T> left, Vector512<T> right) => left ^ right; 4221internal static int CountMatches<T>(Vector512<T> vector) 4235internal static T GetElementUnsafe<T>(in this Vector512<T> vector, int index) 4237Debug.Assert((index >= 0) && (index < Vector512<T>.Count)); 4238ref T address = ref Unsafe.As<Vector512<T>, T>(ref Unsafe.AsRef(in vector)); 4243internal static int IndexOfFirstMatch<T>(Vector512<T> vector) 4265internal static int IndexOfLastMatch<T>(Vector512<T> vector) 4284internal static void SetElementUnsafe<T>(in this Vector512<T> vector, int index, T value) 4286Debug.Assert((index >= 0) && (index < Vector512<T>.Count)); 4287ref T address = ref Unsafe.As<Vector512<T>, T>(ref Unsafe.AsRef(in vector)); 4291internal static void SetLowerUnsafe<T>(in this Vector512<T> vector, Vector256<T> value) => Unsafe.AsRef(in vector._lower) = value; 4293internal static void SetUpperUnsafe<T>(in this Vector512<T> vector, Vector256<T> value) => Unsafe.AsRef(in vector._upper) = value;

10private readonly Vector512<T> _value; 12public Vector512DebugView(Vector512<T> value) 21var items = new byte[Vector512<byte>.Count]; 31var items = new double[Vector512<double>.Count]; 41var items = new short[Vector512<short>.Count]; 51var items = new int[Vector512<int>.Count]; 61var items = new long[Vector512<long>.Count]; 71var items = new nint[Vector512<nint>.Count]; 81var items = new nuint[Vector512<nuint>.Count]; 91var items = new sbyte[Vector512<sbyte>.Count]; 101var items = new float[Vector512<float>.Count]; 111var items = new ushort[Vector512<ushort>.Count]; 121var items = new uint[Vector512<uint>.Count]; 131var items = new ulong[Vector512<ulong>.Count];

2540else if (typeof(TVectorInt64) == typeof(Vector512<long>)) 2542result = (TVectorDouble)(object)Vector512.ConvertToDouble((Vector512<long>)(object)vector); 2575else if (typeof(TVectorInt32) == typeof(Vector512<int>)) 2577result = (TVectorSingle)(object)Vector512.ConvertToSingle((Vector512<int>)(object)vector); 2699else if (typeof(TVectorDouble) == typeof(Vector512<double>)) 2701result = (TVectorDouble)(object)Vector512.FusedMultiplyAdd((Vector512<double>)(object)left, (Vector512<double>)(object)right, (Vector512<double>)(object)addend); 2733else if (typeof(TVector) == typeof(Vector512<double>)) 2767else if (typeof(TVector) == typeof(Vector512<float>)) 2818else if (typeof(TVectorDouble) == typeof(Vector512<double>)) 2824result = (TVectorSingle)(object)Avx512F.ConvertToVector256Single((Vector512<double>)(object)vector); 2828Vector512<double> value = (Vector512<double>)(object)vector; 2867else if (typeof(TVectorDouble) == typeof(Vector512<double>)) 2869Debug.Assert(typeof(TVectorSingle) == typeof(Vector512<float>)); 2870result = (TVectorSingle)(object)Vector512.Narrow((Vector512<double>)(object)lower, (Vector512<double>)(object)upper); 2914else if (typeof(TVectorUInt32) == typeof(Vector512<uint>)) 2917(Vector512<uint>)(object)vector, 2918(Vector512<uint>)(object)shiftAmount 2963else if (typeof(TVectorUInt64) == typeof(Vector512<ulong>)) 2966(Vector512<ulong>)(object)vector, 2967(Vector512<ulong>)(object)shiftAmount 3146Debug.Assert(typeof(TVectorDouble) == typeof(Vector512<double>)); 3197else if (typeof(TVectorSingle) == typeof(Vector512<float>)) 3199Debug.Assert(typeof(TVectorDouble) == typeof(Vector512<double>)); 3200result = (TVectorDouble)(object)Vector512.WidenLower((Vector512<float>)(object)vector); 3237else if (typeof(TVectorSingle) == typeof(Vector512<float>)) 3239Debug.Assert(typeof(TVectorDouble) == typeof(Vector512<double>)); 3240result = (TVectorDouble)(object)Vector512.WidenUpper((Vector512<float>)(object)vector);

4058public static Vector512<float> And(Vector512<float> left, Vector512<float> right) => And(left, right); 4063public static Vector512<double> And(Vector512<double> left, Vector512<double> right) => And(left, right); 4069public static Vector512<float> AndNot(Vector512<float> left, Vector512<float> right) => AndNot(left, right); 4074public static Vector512<double> AndNot(Vector512<double> left, Vector512<double> right) => AndNot(left, right); 4080public static Vector512<int> BroadcastPairScalarToVector512(Vector128<int> value) => BroadcastPairScalarToVector512(value); 4085public static Vector512<uint> BroadcastPairScalarToVector512(Vector128<uint> value) => BroadcastPairScalarToVector512(value); 4090public static Vector512<float> BroadcastPairScalarToVector512(Vector128<float> value) => BroadcastPairScalarToVector512(value); 4096public static unsafe Vector512<long> BroadcastVector128ToVector512(long* address) => BroadcastVector128ToVector512(address); 4102public static unsafe Vector512<ulong> BroadcastVector128ToVector512(ulong* address) => BroadcastVector128ToVector512(address); 4108public static unsafe Vector512<double> BroadcastVector128ToVector512(double* address) => BroadcastVector128ToVector512(address); 4114public static unsafe Vector512<int> BroadcastVector256ToVector512(int* address) => BroadcastVector256ToVector512(address); 4120public static unsafe Vector512<uint> BroadcastVector256ToVector512(uint* address) => BroadcastVector256ToVector512(address); 4126public static unsafe Vector512<float> BroadcastVector256ToVector512(float* address) => BroadcastVector256ToVector512(address); 4132public static Vector512<double> Classify(Vector512<double> value, [ConstantExpected] byte control) => Classify(value, control); 4137public static Vector512<float> Classify(Vector512<float> value, [ConstantExpected] byte control) => Classify(value, control); 4143public static Vector512<byte> Compress(Vector512<byte> merge, Vector512<byte> mask, Vector512<byte> value) => Compress(merge, mask, value); 4148public static Vector512<short> Compress(Vector512<short> merge, Vector512<short> mask, Vector512<short> value) => Compress(merge, mask, value); 4153public static Vector512<sbyte> Compress(Vector512<sbyte> merge, Vector512<sbyte> mask, Vector512<sbyte> value) => Compress(merge, mask, value); 4158public static Vector512<ushort> Compress(Vector512<ushort> merge, Vector512<ushort> mask, Vector512<ushort> value) => Compress(merge, mask, value); 4164public static unsafe void CompressStore(byte* address, Vector512<byte> mask, Vector512<byte> source) => CompressStore(address, mask, source); 4170public static unsafe void CompressStore(short* address, Vector512<short> mask, Vector512<short> source) => CompressStore(address, mask, source); 4176public static unsafe void CompressStore(sbyte* address, Vector512<sbyte> mask, Vector512<sbyte> source) => CompressStore(address, mask, source); 4182public static unsafe void CompressStore(ushort* address, Vector512<ushort> mask, Vector512<ushort> source) => CompressStore(address, mask, source); 4188public static Vector256<float> ConvertToVector256Single(Vector512<long> value) => ConvertToVector256Single(value); 4193public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value) => ConvertToVector256Single(value); 4198public static Vector256<float> ConvertToVector256Single(Vector512<long> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); 4203public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); 4209public static Vector512<double> ConvertToVector512Double(Vector512<long> value) => ConvertToVector512Double(value); 4214public static Vector512<double> ConvertToVector512Double(Vector512<ulong> value) => ConvertToVector512Double(value); 4219public static Vector512<double> ConvertToVector512Double(Vector512<long> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Double(value, mode); 4224public static Vector512<double> ConvertToVector512Double(Vector512<ulong> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Double(value, mode); 4230public static Vector512<long> ConvertToVector512Int64(Vector256<float> value) => ConvertToVector512Int64(value); 4235public static Vector512<long> ConvertToVector512Int64(Vector512<double> value) => ConvertToVector512Int64(value); 4240public static Vector512<long> ConvertToVector512Int64(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int64(value, mode); 4245public static Vector512<long> ConvertToVector512Int64(Vector512<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int64(value, mode); 4251public static Vector512<long> ConvertToVector512Int64WithTruncation(Vector256<float> value) => ConvertToVector512Int64WithTruncation(value); 4256public static Vector512<long> ConvertToVector512Int64WithTruncation(Vector512<double> value) => ConvertToVector512Int64WithTruncation(value); 4262public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value) => ConvertToVector512UInt64(value); 4267public static Vector512<ulong> ConvertToVector512UInt64(Vector512<double> value) => ConvertToVector512UInt64(value); 4272public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt64(value, mode); 4277public static Vector512<ulong> ConvertToVector512UInt64(Vector512<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt64(value, mode); 4283public static Vector512<ulong> ConvertToVector512UInt64WithTruncation(Vector256<float> value) => ConvertToVector512UInt64WithTruncation(value); 4288public static Vector512<ulong> ConvertToVector512UInt64WithTruncation(Vector512<double> value) => ConvertToVector512UInt64WithTruncation(value); 4294public static Vector512<int> DetectConflicts(Vector512<int> value) => DetectConflicts(value); 4299public static Vector512<uint> DetectConflicts(Vector512<uint> value) => DetectConflicts(value); 4304public static Vector512<long> DetectConflicts(Vector512<long> value) => DetectConflicts(value); 4309public static Vector512<ulong> DetectConflicts(Vector512<ulong> value) => DetectConflicts(value); 4315public static Vector512<byte> Expand(Vector512<byte> merge, Vector512<byte> mask, Vector512<byte> value) => Expand(merge, mask, value); 4320public static Vector512<short> Expand(Vector512<short> merge, Vector512<short> mask, Vector512<short> value) => Expand(merge, mask, value); 4325public static Vector512<sbyte> Expand(Vector512<sbyte> merge, Vector512<sbyte> mask, Vector512<sbyte> value) => Expand(merge, mask, value); 4330public static Vector512<ushort> Expand(Vector512<ushort> merge, Vector512<ushort> mask, Vector512<ushort> value) => Expand(merge, mask, value); 4337public static unsafe Vector512<byte> ExpandLoad(byte* address, Vector512<byte> mask, Vector512<byte> merge) => ExpandLoad(address, mask, merge); 4344public static unsafe Vector512<short> ExpandLoad(short* address, Vector512<short> mask, Vector512<short> merge) => ExpandLoad(address, mask, merge); 4351public static unsafe Vector512<sbyte> ExpandLoad(sbyte* address, Vector512<sbyte> mask, Vector512<sbyte> merge) => ExpandLoad(address, mask, merge); 4358public static unsafe Vector512<ushort> ExpandLoad(ushort* address, Vector512<ushort> mask, Vector512<ushort> merge) => ExpandLoad(address, mask, merge); 4364public static new Vector128<long> ExtractVector128(Vector512<long> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 4369public static new Vector128<ulong> ExtractVector128(Vector512<ulong> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 4374public static new Vector128<double> ExtractVector128(Vector512<double> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 4380public static new Vector256<int> ExtractVector256(Vector512<int> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 4385public static new Vector256<uint> ExtractVector256(Vector512<uint> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 4390public static new Vector256<float> ExtractVector256(Vector512<float> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 4396public static new Vector512<long> InsertVector128(Vector512<long> value, Vector128<long> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 4401public static new Vector512<ulong> InsertVector128(Vector512<ulong> value, Vector128<ulong> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 4406public static new Vector512<double> InsertVector128(Vector512<double> value, Vector128<double> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 4412public static new Vector512<int> InsertVector256(Vector512<int> value, Vector256<int> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4417public static new Vector512<uint> InsertVector256(Vector512<uint> value, Vector256<uint> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4422public static new Vector512<float> InsertVector256(Vector512<float> value, Vector256<float> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4428public static Vector512<int> LeadingZeroCount(Vector512<int> value) => LeadingZeroCount(value); 4433public static Vector512<uint> LeadingZeroCount(Vector512<uint> value) => LeadingZeroCount(value); 4438public static Vector512<long> LeadingZeroCount(Vector512<long> value) => LeadingZeroCount(value); 4443public static Vector512<ulong> LeadingZeroCount(Vector512<ulong> value) => LeadingZeroCount(value); 4449public static int MoveMask(Vector512<double> value) => MoveMask(value); 4454public static int MoveMask(Vector512<long> value) => MoveMask(value); 4459public static int MoveMask(Vector512<ulong> value) => MoveMask(value); 4465public static Vector512<long> MultiplyLow(Vector512<long> left, Vector512<long> right) => MultiplyLow(left, right); 4470public static Vector512<ulong> MultiplyLow(Vector512<ulong> left, Vector512<ulong> right) => MultiplyLow(left, right); 4476public static Vector512<byte> MultiShift(Vector512<byte> control, Vector512<ulong> value) => MultiShift(control, value); 4481public static Vector512<sbyte> MultiShift(Vector512<sbyte> control, Vector512<long> value) => MultiShift(control, value); 4487public static Vector512<float> Or(Vector512<float> left, Vector512<float> right) => Or(left, right); 4492public static Vector512<double> Or(Vector512<double> left, Vector512<double> right) => Or(left, right); 4499public static Vector512<sbyte> PermuteVar64x8(Vector512<sbyte> left, Vector512<sbyte> control) => PermuteVar64x8(left, control); 4505public static Vector512<byte> PermuteVar64x8(Vector512<byte> left, Vector512<byte> control) => PermuteVar64x8(left, control); 4512public static Vector512<byte> PermuteVar64x8x2(Vector512<byte> lower, Vector512<byte> indices, Vector512<byte> upper) => PermuteVar64x8x2(lower, indices, upper); 4518public static Vector512<sbyte> PermuteVar64x8x2(Vector512<sbyte> lower, Vector512<sbyte> indices, Vector512<sbyte> upper) => PermuteVar64x8x2(lower, indices, upper); 4524public static Vector512<float> Range(Vector512<float> left, Vector512<float> right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); 4529public static Vector512<double> Range(Vector512<double> left, Vector512<double> right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); 4535public static Vector512<float> Reduce(Vector512<float> value, [ConstantExpected] byte control) => Reduce(value, control); 4540public static Vector512<double> Reduce(Vector512<double> value, [ConstantExpected] byte control) => Reduce(value, control); 4546public static Vector512<float> Xor(Vector512<float> left, Vector512<float> right) => Xor(left, right); 4551public static Vector512<double> Xor(Vector512<double> left, Vector512<double> right) => Xor(left, right);