21public static Vector512<T> Compare(Vector512<T> left, Vector512<T> right) => Vector512.Max(left, right);

19public static abstract Vector512<T> Compare(Vector512<T> left, Vector512<T> right); 75else if (!Vector512.IsHardwareAccelerated || !Vector512<T>.IsSupported || span.Length < Vector512<T>.Count) 102ref T lastVectorStart = ref Unsafe.Add(ref current, span.Length - Vector512<T>.Count); 104Vector512<T> best = Vector512.LoadUnsafe(ref current); 105current = ref Unsafe.Add(ref current, Vector512<T>.Count); 110current = ref Unsafe.Add(ref current, Vector512<T>.Count); 115for (int i = 1; i < Vector512<T>.Count; i++)

21public static Vector512<T> Compare(Vector512<T> left, Vector512<T> right) => Vector512.Min(left, right);

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

22static abstract Vector512<T> Invoke(Vector512<T> x); 31static abstract bool ShouldEarlyExit(Vector512<T> result); 43public static bool ShouldEarlyExit(Vector512<T> result) => Vector512.AnyWhereAllBitsSet(result); 78public static bool ShouldEarlyExit(Vector512<T> result) => 79typeof(T) == typeof(float) ? Vector512.EqualsAny(result.AsUInt32(), Vector512<uint>.Zero) : 80typeof(T) == typeof(double) ? Vector512.EqualsAny(result.AsUInt64(), Vector512<ulong>.Zero) : 81Vector512.EqualsAny(result, Vector512<T>.Zero); 101if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 103oneVectorFromEnd = x.Length - Vector512<T>.Count; 114i += Vector512<T>.Count; 120TAnyAll.ShouldEarlyExit(TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count))))) 235if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 237int vectorFromEnd = x.Length - Vector512<T>.Count; 244i += Vector512<T>.Count; 251i = x.Length - Vector512<T>.Count; 259Vector512<byte> v = TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i)).AsByte(); 261(v & Vector512<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i); 343if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 345int vectorsFromEnd = x.Length - (Vector512<T>.Count * sizeof(T)); 352i += Vector512<T>.Count * sizeof(T); 359i = x.Length - (Vector512<T>.Count * sizeof(T)); 367Vector512<byte> v = 370TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<T>.Count))).AsUInt16()); 372(v & Vector512<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i); 460if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 462int vectorsFromEnd = x.Length - (Vector512<T>.Count * sizeof(T)); 469i += Vector512<T>.Count * sizeof(T); 476i = x.Length - (Vector512<T>.Count * sizeof(T)); 484Vector512<byte> v = 488TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<T>.Count))).AsUInt32()), 490TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (2 * Vector512<T>.Count)))).AsUInt32(), 491TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (3 * Vector512<T>.Count)))).AsUInt32())); 493(v & Vector512<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i); 587if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 591int vectorsFromEnd = x.Length - (Vector512<T>.Count * sizeof(T)); 598i += Vector512<T>.Count * sizeof(T); 605i = x.Length - (Vector512<T>.Count * sizeof(T)); 613Vector512<byte> v = 618TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<T>.Count))).AsUInt64()), 620TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (2 * Vector512<T>.Count)))).AsUInt64(), 621TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (3 * Vector512<T>.Count)))).AsUInt64())), 624TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (4 * Vector512<T>.Count)))).AsUInt64(), 625TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (5 * Vector512<T>.Count)))).AsUInt64()), 627TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (6 * Vector512<T>.Count)))).AsUInt64(), 628TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (7 * Vector512<T>.Count)))).AsUInt64()))); 630(v & Vector512<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i);

17static abstract void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex); 115private static int IndexOfFinalAggregate<T, TIndexOfOperator>(Vector512<T> result, Vector512<T> resultIndex)

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

20static abstract (Vector512<T> First, Vector512<T> Second) Invoke(Vector512<T> x); 30static abstract (Vector512<T> First, Vector512<T> Second) Invoke(Vector512<T> x, Vector512<T> y); 41public static (Vector512<T> First, Vector512<T> Second) Invoke(Vector512<T> x, Vector512<T> y) => TOperator.Invoke(y, x); 71if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TUnaryOperator.Vectorizable) 73oneVectorFromEnd = x.Length - Vector512<T>.Count; 79(Vector512<T> first, Vector512<T> second) = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i)); 83i += Vector512<T>.Count; 90i = x.Length - Vector512<T>.Count; 92(Vector512<T> first, Vector512<T> second) = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i)); 206if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TOperator.Vectorizable) 208oneVectorFromEnd = x.Length - Vector512<T>.Count; 214(Vector512<T> first, Vector512<T> second) = TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i), Vector512.LoadUnsafe(ref yRef, (uint)i)); 218i += Vector512<T>.Count; 225Vector512<T> mask = Vector512.Equals(CreateRemainderMaskVector512<T>(x.Length - i), Vector512<T>.Zero); 227i = x.Length - Vector512<T>.Count; 229Vector512<T> first = Vector512.ConditionalSelect(mask, 233Vector512<T> second = Vector512.ConditionalSelect(mask, 387if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TOperator.Vectorizable) 389oneVectorFromEnd = x.Length - Vector512<T>.Count; 392Vector512<T> yVec = Vector512.Create(y); 397(Vector512<T> first, Vector512<T> second) = TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i), yVec); 401i += Vector512<T>.Count; 408Vector512<T> mask = Vector512.Equals(CreateRemainderMaskVector512<T>(x.Length - i), Vector512<T>.Zero); 410i = x.Length - Vector512<T>.Count; 412Vector512<T> first = Vector512.ConditionalSelect(mask, 416Vector512<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;

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

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

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

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)

227public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> min, Vector512<T> max) => Vector512.Clamp(x, min, max); 275public static Vector512<T> Invoke(Vector512<T> min, Vector512<T> max, Vector512<T> x) => Vector512.Clamp(x, min, max); 324public 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();

172public static Vector512<float> Invoke(Vector512<int> x) => Vector512.ConvertToSingle(x); 183public static Vector512<float> Invoke(Vector512<uint> x) => Vector512.ConvertToSingle(x); 194public static Vector512<double> Invoke(Vector512<ulong> x) => Vector512.ConvertToDouble(x); 205public static Vector512<double> Invoke(Vector512<long> x) => Vector512.ConvertToDouble(x); 216public static (Vector512<double> Lower, Vector512<double> Upper) Invoke(Vector512<float> x) => Vector512.Widen(x); 227public static Vector512<float> Invoke(Vector512<double> lower, Vector512<double> upper) => Vector512.Narrow(lower, upper); 238public static (Vector512<ushort> Lower, Vector512<ushort> Upper) Invoke(Vector512<byte> x) => Vector512.Widen(x); 267public static (Vector512<uint>, Vector512<uint>, Vector512<uint>, Vector512<uint>) Invoke(Vector512<byte> x) 269(Vector512<ushort> Lower, Vector512<ushort> Upper) ushorts = Vector512.Widen(x); 270(Vector512<uint> Lower, Vector512<uint> Upper) uintsLower = Vector512.Widen(ushorts.Lower); 271(Vector512<uint> Lower, Vector512<uint> Upper) uintsUpper = Vector512.Widen(ushorts.Upper); 308public static (Vector512<float>, Vector512<float>, Vector512<float>, Vector512<float>) Invoke(Vector512<byte> x) 328public static (Vector512<short> Lower, Vector512<short> Upper) Invoke(Vector512<sbyte> x) => Vector512.Widen(x); 339public static (Vector512<uint> Lower, Vector512<uint> Upper) Invoke(Vector512<ushort> x) => Vector512.Widen(x); 350public static (Vector512<int> Lower, Vector512<int> Upper) Invoke(Vector512<short> x) => Vector512.Widen(x); 361public static (Vector512<ulong> Lower, Vector512<ulong> Upper) Invoke(Vector512<uint> x) => Vector512.Widen(x); 372public static (Vector512<long> Lower, Vector512<long> Upper) Invoke(Vector512<int> x) => Vector512.Widen(x); 498public static (Vector512<float> Lower, Vector512<float> Upper) Invoke(Vector512<short> x) 500(Vector512<int> lowerInt32, Vector512<int> upperInt32) = Vector512.Widen(x); 505static Vector512<float> HalfAsWidenedUInt32ToSingle(Vector512<uint> value) 508Vector512<uint> sign = value & Vector512.Create(SingleSignMask); 511Vector512<uint> bitValueInProcess = value; 514Vector512<uint> offsetExponent = bitValueInProcess & Vector512.Create(HalfExponentMask); 517Vector512<uint> subnormalMask = Vector512.Equals(offsetExponent, Vector512<uint>.Zero); 520Vector512<uint> infinityOrNaNMask = Vector512.Equals(offsetExponent, Vector512.Create(HalfExponentMask)); 523Vector512<uint> maskedExponentLowerBound = subnormalMask & Vector512.Create(ExponentLowerBound); 526Vector512<uint> offsetMaskedExponentLowerBound = Vector512.Create(ExponentOffset) | maskedExponentLowerBound; 532offsetMaskedExponentLowerBound = Vector512.ConditionalSelect(Vector512.Equals(infinityOrNaNMask, Vector512<uint>.Zero), 543Vector512<uint> absoluteValue = (bitValueInProcess.AsSingle() - maskedExponentLowerBound.AsSingle()).AsUInt32(); 703public static Vector512<ushort> Invoke(Vector512<float> lower, Vector512<float> upper) 709static Vector512<uint> SingleToHalfAsWidenedUInt32(Vector512<float> value) 711Vector512<uint> bitValue = value.AsUInt32(); 714Vector512<uint> sign = Vector512.ShiftRightLogical(bitValue & Vector512.Create(SingleSignMask), 16); 717Vector512<uint> realMask = Vector512.Equals(value, value).AsUInt32(); 726Vector512<uint> exponentOffset0 = Vector512.Max(value, Vector512.Create(MinExp).AsSingle()).AsUInt32(); 739Vector512<uint> maskedHalfExponentForNaN = ~realMask & Vector512.Create(ExponentMask); 745Vector512<uint> newExponent = Vector512.ShiftRightLogical(bitValue, 13); 757Vector512<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 ?

116public static Vector512<int> Invoke(Vector512<float> x) => Vector512.ConvertToInt32(x); 132public static Vector512<uint> Invoke(Vector512<float> x) => Vector512.ConvertToUInt32(x); 148public static Vector512<ulong> Invoke(Vector512<double> x) => Vector512.ConvertToUInt64(x); 164public static Vector512<long> Invoke(Vector512<double> x) => Vector512.ConvertToInt64(x); 175public static Vector512<byte> Invoke(Vector512<ushort> lower, Vector512<ushort> upper) => Vector512.Narrow(lower, upper); 186public static Vector512<sbyte> Invoke(Vector512<short> lower, Vector512<short> upper) => Vector512.Narrow(lower, upper); 197public static Vector512<ushort> Invoke(Vector512<uint> lower, Vector512<uint> upper) => Vector512.Narrow(lower, upper); 208public static Vector512<short> Invoke(Vector512<int> lower, Vector512<int> upper) => Vector512.Narrow(lower, upper); 219public static Vector512<uint> Invoke(Vector512<ulong> lower, Vector512<ulong> upper) => Vector512.Narrow(lower, upper); 230public static Vector512<int> Invoke(Vector512<long> lower, Vector512<long> upper) => Vector512.Narrow(lower, upper); 241public static Vector512<TTo> Invoke(Vector512<TFrom> x) => throw new NotSupportedException();

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

126public 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;

73public 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;

99public 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)

202public 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);

77public 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;

87public static void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex) 89Vector512<T> useResult = Vector512.GreaterThan(result, current); 90Vector512<T> equalMask = Vector512.Equals(result, current); 92if (equalMask != Vector512<T>.Zero) 94Vector512<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex); 98Vector512<T> currentNegative = IsNegative(current); 99Vector512<T> sameSign = Vector512.Equals(IsNegative(result).AsInt32(), currentNegative.AsInt32()).As<int, T>(); 148if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 153static Vector512<T> CreateVector512T(int i) => 160Vector512<T> resultIndex = 162sizeof(T) == sizeof(long) ? Vector512<long>.Indices.As<long, T>() : 163sizeof(T) == sizeof(int) ? Vector512<int>.Indices.As<int, T>() : 164sizeof(T) == sizeof(short) ? Vector512<short>.Indices.As<short, T>() : 165Vector512<byte>.Indices.As<byte, T>(); 172Vector512<T> currentIndex = resultIndex; 173Vector512<T> increment = CreateVector512T(Vector512<T>.Count); 177Vector512<T> result = Vector512.LoadUnsafe(ref xRef); 178Vector512<T> current; 180Vector512<T> nanMask; 184if (nanMask != Vector512<T>.Zero) 190int oneVectorFromEnd = x.Length - Vector512<T>.Count; 191int i = Vector512<T>.Count; 203if (nanMask != Vector512<T>.Zero) 211i += Vector512<T>.Count; 217current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 223if (nanMask != Vector512<T>.Zero) 449private static int IndexOfFirstMatch<T>(Vector512<T> mask) => 460private static unsafe Vector512<T> IndexLessThan<T>(Vector512<T> indices1, Vector512<T> indices2) => 504private static unsafe Vector512<T> ElementWiseSelect<T>(Vector512<T> mask, Vector512<T> left, Vector512<T> right)

86public static void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex) 88Vector512<T> resultMag = Vector512.Abs(result), currentMag = Vector512.Abs(current); 89Vector512<T> useResult = Vector512.GreaterThan(resultMag, currentMag); 90Vector512<T> equalMask = Vector512.Equals(resultMag, currentMag); 92if (equalMask != Vector512<T>.Zero) 94Vector512<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex); 98Vector512<T> currentNegative = IsNegative(current); 99Vector512<T> sameSign = Vector512.Equals(IsNegative(result).AsInt32(), currentNegative.AsInt32()).As<int, T>();

84public static void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex) 86Vector512<T> useResult = Vector512.LessThan(result, current); 87Vector512<T> equalMask = Vector512.Equals(result, current); 89if (equalMask != Vector512<T>.Zero) 91Vector512<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex); 95Vector512<T> resultNegative = IsNegative(result); 96Vector512<T> sameSign = Vector512.Equals(resultNegative.AsInt32(), IsNegative(current).AsInt32()).As<int, T>();

86public static void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex) 88Vector512<T> resultMag = Vector512.Abs(result), currentMag = Vector512.Abs(current); 89Vector512<T> useResult = Vector512.LessThan(resultMag, currentMag); 90Vector512<T> equalMask = Vector512.Equals(resultMag, currentMag); 92if (equalMask != Vector512<T>.Zero) 94Vector512<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex); 98Vector512<T> resultNegative = IsNegative(result); 99Vector512<T> sameSign = Vector512.Equals(resultNegative.AsInt32(), IsNegative(current).AsInt32()).As<int, T>();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

65public static Vector512<T> Invoke(Vector512<T> x) => 66Vector512.Equals(x & (x - Vector512<T>.One), Vector512<T>.Zero) & 67Vector512.GreaterThan(x, Vector512<T>.Zero);

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

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

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

135public static Vector512<T> Invoke(Vector512<T> x) 144Vector512<byte> lookupVectorA = 153Vector512<byte> lookupVectorB = Vector512.Create((byte)1); 154Vector512<byte> bit7ZeroMask = Avx512BW.CompareLessThan(x.AsByte(), Vector512.Create((byte)128)); 162Vector512<uint> lowHalf = Vector512.Create((uint)0x0000FFFF); 163Vector512<uint> x_bot16 = Avx512F.Or(Avx512F.ShiftLeftLogical(x.AsUInt32(), 16), lowHalf); 164Vector512<uint> x_top16 = Avx512F.Or(x.AsUInt32(), lowHalf); 165Vector512<uint> lz_bot16 = Avx512CD.LeadingZeroCount(x_bot16); 166Vector512<uint> lz_top16 = Avx512CD.LeadingZeroCount(x_top16); 167Vector512<uint> lz_top16_shift = Avx512F.ShiftLeftLogical(lz_top16, 16);

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

155public static Vector512<T> Invoke(Vector512<T> x) 189public 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);

101public 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);

145public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) 163public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x); 198private static Vector512<T> IsNaN<T>(Vector512<T> vector) 273private static Vector512<T> IsNegative<T>(Vector512<T> vector) 363private static Vector512<T> IsPositive<T>(Vector512<T> vector) 409if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 415Vector512<T> result = Vector512.LoadUnsafe(ref xRef, 0); 416Vector512<T> current; 418Vector512<T> nanMask; 423if (nanMask != Vector512<T>.Zero) 429int oneVectorFromEnd = x.Length - Vector512<T>.Count; 430int i = Vector512<T>.Count; 442if (nanMask != Vector512<T>.Zero) 449i += Vector512<T>.Count; 455current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 461if (nanMask != Vector512<T>.Zero)

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

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

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

143public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) 161public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MinOperator<T>>(x);

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

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

146public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) 166public 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;

203public 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)

66public 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); 170public static Vector512<T> Invoke(Vector512<T> x) 180return Vector512<T>.One / x; 236public static Vector512<T> Invoke(Vector512<T> x) 246return 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));

229public static Vector512<T> Invoke(Vector512<T> x) 292public static Vector512<T> Invoke(Vector512<T> x) 348public Vector512<T> Invoke(Vector512<T> x) 350Vector512<T> limit = Vector512.Create(typeof(T) == typeof(float) ? T.CreateTruncating(Single_RoundLimit) : T.CreateTruncating(Double_RoundLimit)); 370public Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();

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

65public Vector512<T> Invoke(Vector512<T> x) => x << _amount; 78public Vector512<T> Invoke(Vector512<T> x) => x >> _amount; 91public 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));

92public static Vector512<int> Invoke(Vector512<T> x) 96return Vector512.ConditionalSelect(Vector512.Equals(x, Vector512<T>.Zero).AsInt32(), 97Vector512<int>.Zero, 98Vector512<int>.One); 103Vector512<int> value = x.AsInt32(); 107if (Vector512.EqualsAny(IsNaN(x).AsInt32(), Vector512<int>.AllBitsSet)) 112return Vector512.ConditionalSelect(Vector512.LessThan(x, Vector512<T>.Zero).AsInt32(), 114Vector512.ConditionalSelect(Vector512.GreaterThan(x, Vector512<T>.Zero).AsInt32(), 115Vector512<int>.One, 116Vector512<int>.Zero));

115public 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);

61public Vector512<T> Invoke(Vector512<T> x) 63Vector512<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));

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

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

664Vector512<sbyte> vbmiLookup0 = Vector512.Create(decoder.VbmiLookup0).AsSByte(); 665Vector512<sbyte> vbmiLookup1 = Vector512.Create(decoder.VbmiLookup1).AsSByte(); 666Vector512<byte> vbmiPackedLanesControl = Vector512.Create( 672Vector512<sbyte> mergeConstant0 = Vector512.Create(0x01400140).AsSByte(); 673Vector512<short> mergeConstant1 = Vector512.Create(0x00011000).AsInt16(); 679if (!decoder.TryLoadVector512(src, srcStart, sourceLength, out Vector512<sbyte> str)) 688Vector512<sbyte> origIndex = Avx512Vbmi.PermuteVar64x8x2(vbmiLookup0, str, vbmiLookup1); 689Vector512<sbyte> errorVec = (origIndex.AsInt32() | str.AsInt32()).AsSByte(); 697Vector512<short> multiAdd1 = Avx512BW.MultiplyAddAdjacent(origIndex.AsByte(), mergeConstant0); 699Vector512<int> multiAdd2 = Avx512BW.MultiplyAddAdjacent(multiAdd1, mergeConstant1); 704AssertWrite<Vector512<sbyte>>(dest, destStart, destLength); 1347public unsafe bool TryLoadVector512(byte* src, byte* srcStart, int sourceLength, out Vector512<sbyte> str) 1349AssertRead<Vector512<sbyte>>(src, srcStart, sourceLength);

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); 730public unsafe void StoreVector512ToDestination(byte* dest, byte* destStart, int destLength, Vector512<byte> str) 732AssertWrite<Vector512<sbyte>>(dest, destStart, destLength);

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

570public unsafe bool TryLoadVector512(byte* src, byte* srcStart, int sourceLength, out Vector512<sbyte> str) => 663public unsafe bool TryLoadVector512(ushort* src, ushort* srcStart, int sourceLength, out Vector512<sbyte> str) 665AssertRead<Vector512<ushort>>(src, srcStart, sourceLength); 666Vector512<ushort> utf16VectorLower = Vector512.Load(src); 667Vector512<ushort> utf16VectorUpper = Vector512.Load(src + 32);

288public unsafe void StoreVector512ToDestination(byte* dest, byte* destStart, int destLength, Vector512<byte> str) => 382public unsafe void StoreVector512ToDestination(ushort* dest, ushort* destStart, int destLength, Vector512<byte> str) 384AssertWrite<Vector512<ushort>>(dest, destStart, destLength); 385(Vector512<ushort> utf16LowVector, Vector512<ushort> utf16HighVector) = Vector512.Widen(str); 387utf16HighVector.Store(dest + Vector512<ushort>.Count);

173for (; i <= (uint)values.Length - Vector512<byte>.Count; i += (uint)Vector512<byte>.Count) 175Vector512<byte> vector = Vector512.LoadUnsafe(ref value, i); 176Vector512<byte> isFalse = Vector512.Equals(vector, Vector512<byte>.Zero); 425i = Apply<Vector512<byte>>(count, thisArray, valueArray); 740if (Avx512BW.IsSupported && (uint)_bitLength >= Vector512<byte>.Count) 745Vector512<byte> shuffleMask = Vector512.Create(lowerShuffleMask_CopyToBoolArray256, upperShuffleMask_CopyToBoolArray256); 746Vector512<byte> bitMask = Vector512.Create(0x80402010_08040201).AsByte(); 747Vector512<byte> ones = Vector512.Create((byte)1); 751for (; (i + Vector512<byte>.Count) <= (uint)_bitLength; i += (uint)Vector512<byte>.Count) 754Vector512<ulong> scalar = Vector512.Create(bits); 755Vector512<byte> shuffled = Avx512BW.Shuffle(scalar.AsByte(), shuffleMask); 756Vector512<byte> extracted = Avx512F.And(shuffled, bitMask); 760Vector512<byte> normalized = Avx512BW.Min(extracted, ones);

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

400if (Vector<double>.Count == Vector512<double>.Count) 423if (Vector<double>.Count == Vector512<double>.Count) 531if (Vector<float>.Count == Vector512<float>.Count) 698if (Vector<T>.Count == Vector512<T>.Count) 1355if (Vector<T>.Count == Vector512<T>.Count) 1601if (Vector<T>.Count == Vector512<T>.Count) 2652if (Vector<uint>.Count == Vector512<uint>.Count) 2678if (Vector<ulong>.Count == Vector512<ulong>.Count)

767return VectorMath.CosSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 1672return VectorMath.ExpSingle<Vector256<float>, Vector256<uint>, Vector512<double>, Vector512<ulong>>(vector); 1924return VectorMath.HypotSingle<Vector256<float>, Vector512<double>>(x, y); 3722return VectorMath.SinSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 3766return VectorMath.SinCosSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 3921/// <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> 3924/// <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> 3927public static Vector512<T> ToVector512<T>(this Vector256<T> vector) 3931Vector512<T> result = default; 3936/// <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> 3939/// <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> 3942public static Vector512<T> ToVector512Unsafe<T>(this Vector256<T> vector) 3949Unsafe.SkipInit(out Vector512<T> result);

61public static Vector512<T> Abs<T>(Vector512<T> vector) 82public static Vector512<T> Add<T>(Vector512<T> left, Vector512<T> right) => left + right; 87public static Vector512<T> AddSaturate<T>(Vector512<T> left, Vector512<T> right) 105public static bool All<T>(Vector512<T> vector, T value) => vector == Create(value); 110public static bool AllWhereAllBitsSet<T>(Vector512<T> vector) 134public static Vector512<T> AndNot<T>(Vector512<T> left, Vector512<T> right) => left & ~right; 139public static bool Any<T>(Vector512<T> vector, T value) => EqualsAny(vector, Create(value)); 144public static bool AnyWhereAllBitsSet<T>(Vector512<T> vector) 168public static Vector512<TTo> As<TFrom, TTo>(this Vector512<TFrom> vector) 176return Unsafe.BitCast<Vector512<TFrom>, Vector512<TTo>>(vector); 180/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Byte&gt;" />.</summary> 186public static Vector512<byte> AsByte<T>(this Vector512<T> vector) => vector.As<T, byte>(); 188/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Double&gt;" />.</summary> 194public static Vector512<double> AsDouble<T>(this Vector512<T> vector) => vector.As<T, double>(); 196/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Int16&gt;" />.</summary> 202public static Vector512<short> AsInt16<T>(this Vector512<T> vector) => vector.As<T, short>(); 204/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Int32&gt;" />.</summary> 210public static Vector512<int> AsInt32<T>(this Vector512<T> vector) => vector.As<T, int>(); 212/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Int64&gt;" />.</summary> 218public static Vector512<long> AsInt64<T>(this Vector512<T> vector) => vector.As<T, long>(); 220/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;IntPtr&gt;" />.</summary> 226public static Vector512<nint> AsNInt<T>(this Vector512<T> vector) => vector.As<T, nint>(); 228/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UIntPtr&gt;" />.</summary> 235public static Vector512<nuint> AsNUInt<T>(this Vector512<T> vector) => vector.As<T, nuint>(); 237/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;SByte&gt;" />.</summary> 244public static Vector512<sbyte> AsSByte<T>(this Vector512<T> vector) => vector.As<T, sbyte>(); 246/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Single&gt;" />.</summary> 252public static Vector512<float> AsSingle<T>(this Vector512<T> vector) => vector.As<T, float>(); 254/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UInt16&gt;" />.</summary> 261public static Vector512<ushort> AsUInt16<T>(this Vector512<T> vector) => vector.As<T, ushort>(); 263/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UInt32&gt;" />.</summary> 270public static Vector512<uint> AsUInt32<T>(this Vector512<T> vector) => vector.As<T, uint>(); 272/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UInt64&gt;" />.</summary> 279public static Vector512<ulong> AsUInt64<T>(this Vector512<T> vector) => vector.As<T, ulong>(); 281/// <summary>Reinterprets a <see cref="Vector{T}" /> as a new <see cref="Vector512{T}" />.</summary> 284/// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector512{T}" />.</returns> 288public static Vector512<T> AsVector512<T>(this Vector<T> value) 290Debug.Assert(Vector512<T>.Count >= Vector<T>.Count); 293Vector512<T> result = default; 294Unsafe.WriteUnaligned(ref Unsafe.As<Vector512<T>, byte>(ref result), value); 298/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see cref="Vector{T}" />.</summary> 305public static Vector<T> AsVector<T>(this Vector512<T> value) 307Debug.Assert(Vector512<T>.Count >= Vector<T>.Count); 310ref byte address = ref Unsafe.As<Vector512<T>, byte>(ref value); 321public static Vector512<T> BitwiseAnd<T>(Vector512<T> left, Vector512<T> right) => left & right; 330public static Vector512<T> BitwiseOr<T>(Vector512<T> left, Vector512<T> right) => left | right; 337internal static Vector512<T> Ceiling<T>(Vector512<T> vector) 366public static Vector512<float> Ceiling(Vector512<float> vector) => Ceiling<float>(vector); 373public static Vector512<double> Ceiling(Vector512<double> vector) => Ceiling<double>(vector); 377public static Vector512<T> Clamp<T>(Vector512<T> value, Vector512<T> min, Vector512<T> max) 385public static Vector512<T> ClampNative<T>(Vector512<T> value, Vector512<T> min, Vector512<T> max) 401public static Vector512<T> ConditionalSelect<T>(Vector512<T> condition, Vector512<T> left, Vector512<T> right) => (left & condition) | AndNot(right, condition); 408public static Vector512<double> ConvertToDouble(Vector512<long> vector) 422public static Vector512<double> ConvertToDouble(Vector512<ulong> vector) 435public static Vector512<int> ConvertToInt32(Vector512<float> vector) 448public static Vector512<int> ConvertToInt32Native(Vector512<float> vector) 461public static Vector512<long> ConvertToInt64(Vector512<double> vector) 474public static Vector512<long> ConvertToInt64Native(Vector512<double> vector) 487public static Vector512<float> ConvertToSingle(Vector512<int> vector) 501public static Vector512<float> ConvertToSingle(Vector512<uint> vector) 515public static Vector512<uint> ConvertToUInt32(Vector512<float> vector) 529public static Vector512<uint> ConvertToUInt32Native(Vector512<float> vector) 543public static Vector512<ulong> ConvertToUInt64(Vector512<double> vector) 557public static Vector512<ulong> ConvertToUInt64Native(Vector512<double> vector) 568public static Vector512<T> CopySign<T>(Vector512<T> value, Vector512<T> sign) 580return VectorMath.CopySign<Vector512<T>, T>(value, sign); 591/// <summary>Copies a <see cref="Vector512{T}" /> to a given array.</summary> 595/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</exception> 598public static void CopyTo<T>(this Vector512<T> vector, T[] destination) 602if (destination.Length < Vector512<T>.Count) 610/// <summary>Copies a <see cref="Vector512{T}" /> to a given array starting at the specified index.</summary> 615/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</exception> 619public static void CopyTo<T>(this Vector512<T> vector, T[] destination, int startIndex) 628if ((destination.Length - startIndex) < Vector512<T>.Count) 636/// <summary>Copies a <see cref="Vector512{T}" /> to a given span.</summary> 640/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</exception> 642public static void CopyTo<T>(this Vector512<T> vector, Span<T> destination) 644if ((uint)destination.Length < (uint)Vector512<T>.Count) 654public static Vector512<double> Cos(Vector512<double> vector) 658return VectorMath.CosDouble<Vector512<double>, Vector512<long>>(vector); 671public static Vector512<float> Cos(Vector512<float> vector) 675return VectorMath.CosSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 689public static int Count<T>(Vector512<T> vector, T value) => BitOperations.PopCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 694public static int CountWhereAllBitsSet<T>(Vector512<T> vector) 710/// <summary>Creates a new <see cref="Vector512{T}" /> instance with all elements initialized to the specified value.</summary> 713/// <returns>A new <see cref="Vector512{T}" /> with all elements initialized to <paramref name="value" />.</returns> 716public static Vector512<T> Create<T>(T value) 727public static Vector512<byte> Create(byte value) => Create<byte>(value); 734public static Vector512<double> Create(double value) => Create<double>(value); 741public static Vector512<short> Create(short value) => Create<short>(value); 748public static Vector512<int> Create(int value) => Create<int>(value); 755public static Vector512<long> Create(long value) => Create<long>(value); 761public static Vector512<nint> Create(nint value) => Create<nint>(value); 768public static Vector512<nuint> Create(nuint value) => Create<nuint>(value); 776public static Vector512<sbyte> Create(sbyte value) => Create<sbyte>(value); 783public static Vector512<float> Create(float value) => Create<float>(value); 791public static Vector512<ushort> Create(ushort value) => Create<ushort>(value); 799public static Vector512<uint> Create(uint value) => Create<uint>(value); 807public static Vector512<ulong> Create(ulong value) => Create<ulong>(value); 809/// <summary>Creates a new <see cref="Vector512{T}" /> from a given array.</summary> 812/// <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> 813/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" /> is less than <see cref="Vector512{T}.Count" />.</exception> 816public static Vector512<T> Create<T>(T[] values) 820if (values.Length < Vector512<T>.Count) 825return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref values[0])); 828/// <summary>Creates a new <see cref="Vector512{T}" /> from a given array.</summary> 832/// <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> 833/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" />, starting from <paramref name="index" />, is less than <see cref="Vector512{T}.Count" />.</exception> 836public static Vector512<T> Create<T>(T[] values, int index) 840if ((index < 0) || ((values.Length - index) < Vector512<T>.Count)) 845return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref values[index])); 848/// <summary>Creates a new <see cref="Vector512{T}" /> from a given readonly span.</summary> 851/// <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> 852/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" /> is less than <see cref="Vector512{T}.Count" />.</exception> 855public static Vector512<T> Create<T>(ReadOnlySpan<T> values) 857if (values.Length < Vector512<T>.Count) 862return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 934public 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, 958public static Vector512<double> Create(double e0, double e1, double e2, double e3, double e4, double e5, double e6, double e7) 1003public 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, 1033public 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) 1054public static Vector512<long> Create(long e0, long e1, long e2, long e3, long e4, long e5, long e6, long e7) 1132public 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, 1164public 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) 1210public 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, 1241public 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) 1263public static Vector512<ulong> Create(ulong e0, ulong e1, ulong e2, ulong e3, ulong e4, ulong e5, ulong e6, ulong e7) 1271/// <summary>Creates a new <see cref="Vector512{T}" /> instance with all 64-bit parts initialized to a specified value.</summary> 1277public static Vector512<T> Create<T>(Vector64<T> value) => Create(Vector128.Create(value, value)); 1279/// <summary>Creates a new <see cref="Vector512{T}" /> instance with all 128-bit parts initialized to a specified value.</summary> 1285public static Vector512<T> Create<T>(Vector128<T> value) => Create(Vector256.Create(value, value)); 1287/// <summary>Creates a new <see cref="Vector512{T}" /> instance with the lower and upper 256-bits initialized to a specified value.</summary> 1293public static Vector512<T> Create<T>(Vector256<T> value) => Create(value, value); 1295/// <summary>Creates a new <see cref="Vector512{T}" /> instance from two <see cref="Vector256{T}" /> instances.</summary> 1299/// <returns>A new <see cref="Vector512{T}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns> 1302public static Vector512<T> Create<T>(Vector256<T> lower, Vector256<T> upper) 1305Unsafe.SkipInit(out Vector512<T> result); 1317public static Vector512<byte> Create(Vector256<byte> lower, Vector256<byte> upper) => Create<byte>(lower, upper); 1324public static Vector512<double> Create(Vector256<double> lower, Vector256<double> upper) => Create<double>(lower, upper); 1330public static Vector512<short> Create(Vector256<short> lower, Vector256<short> upper) => Create<short>(lower, upper); 1337public static Vector512<int> Create(Vector256<int> lower, Vector256<int> upper) => Create<int>(lower, upper); 1343public static Vector512<long> Create(Vector256<long> lower, Vector256<long> upper) => Create<long>(lower, upper); 1349public static Vector512<nint> Create(Vector256<nint> lower, Vector256<nint> upper) => Create<nint>(lower, upper); 1356public static Vector512<nuint> Create(Vector256<nuint> lower, Vector256<nuint> upper) => Create<nuint>(lower, upper); 1363public static Vector512<sbyte> Create(Vector256<sbyte> lower, Vector256<sbyte> upper) => Create<sbyte>(lower, upper); 1370public static Vector512<float> Create(Vector256<float> lower, Vector256<float> upper) => Create<float>(lower, upper); 1377public static Vector512<ushort> Create(Vector256<ushort> lower, Vector256<ushort> upper) => Create<ushort>(lower, upper); 1385public static Vector512<uint> Create(Vector256<uint> lower, Vector256<uint> upper) => Create<uint>(lower, upper); 1392public static Vector512<ulong> Create(Vector256<ulong> lower, Vector256<ulong> upper) => Create<ulong>(lower, upper); 1394/// <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> 1397/// <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> 1400public static Vector512<T> CreateScalar<T>(T value) => Vector256.CreateScalar(value).ToVector512(); 1406public static Vector512<byte> CreateScalar(byte value) => CreateScalar<byte>(value); 1412public static Vector512<double> CreateScalar(double value) => CreateScalar<double>(value); 1418public static Vector512<short> CreateScalar(short value) => CreateScalar<short>(value); 1424public static Vector512<int> CreateScalar(int value) => CreateScalar<int>(value); 1430public static Vector512<long> CreateScalar(long value) => CreateScalar<long>(value); 1436public static Vector512<nint> CreateScalar(nint value) => CreateScalar<nint>(value); 1443public static Vector512<nuint> CreateScalar(nuint value) => CreateScalar<nuint>(value); 1450public static Vector512<sbyte> CreateScalar(sbyte value) => CreateScalar<sbyte>(value); 1456public static Vector512<float> CreateScalar(float value) => CreateScalar<float>(value); 1463public static Vector512<ushort> CreateScalar(ushort value) => CreateScalar<ushort>(value); 1470public static Vector512<uint> CreateScalar(uint value) => CreateScalar<uint>(value); 1477public static Vector512<ulong> CreateScalar(ulong value) => CreateScalar<ulong>(value); 1479/// <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> 1482/// <returns>A new <see cref="Vector512{T}" /> instance with the first element initialized to <paramref name="value" /> and the remaining elements left uninitialized.</returns> 1486public static Vector512<T> CreateScalarUnsafe<T>(T value) 1492Unsafe.SkipInit(out Vector512<T> result); 1502public static Vector512<byte> CreateScalarUnsafe(byte value) => CreateScalarUnsafe<byte>(value); 1508public static Vector512<double> CreateScalarUnsafe(double value) => CreateScalarUnsafe<double>(value); 1514public static Vector512<short> CreateScalarUnsafe(short value) => CreateScalarUnsafe<short>(value); 1520public static Vector512<int> CreateScalarUnsafe(int value) => CreateScalarUnsafe<int>(value); 1526public static Vector512<long> CreateScalarUnsafe(long value) => CreateScalarUnsafe<long>(value); 1532public static Vector512<nint> CreateScalarUnsafe(nint value) => CreateScalarUnsafe<nint>(value); 1539public static Vector512<nuint> CreateScalarUnsafe(nuint value) => CreateScalarUnsafe<nuint>(value); 1546public static Vector512<sbyte> CreateScalarUnsafe(sbyte value) => CreateScalarUnsafe<sbyte>(value); 1552public static Vector512<float> CreateScalarUnsafe(float value) => CreateScalarUnsafe<float>(value); 1559public static Vector512<ushort> CreateScalarUnsafe(ushort value) => CreateScalarUnsafe<ushort>(value); 1566public static Vector512<uint> CreateScalarUnsafe(uint value) => CreateScalarUnsafe<uint>(value); 1573public static Vector512<ulong> CreateScalarUnsafe(ulong value) => CreateScalarUnsafe<ulong>(value); 1575/// <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> 1579/// <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> 1582public static Vector512<T> CreateSequence<T>(T start, T step) => (Vector512<T>.Indices * step) + Create(start); 1587public static Vector512<double> DegreesToRadians(Vector512<double> degrees) 1591return VectorMath.DegreesToRadians<Vector512<double>, double>(degrees); 1605public static Vector512<float> DegreesToRadians(Vector512<float> degrees) 1609return VectorMath.DegreesToRadians<Vector512<float>, float>(degrees); 1628public static Vector512<T> Divide<T>(Vector512<T> left, Vector512<T> right) => left / right; 1636public static Vector512<T> Divide<T>(Vector512<T> left, T right) => left / right; 1646public static T Dot<T>(Vector512<T> left, Vector512<T> right) => Sum(left * right); 1656public static Vector512<T> Equals<T>(Vector512<T> left, Vector512<T> right) 1671public static bool EqualsAll<T>(Vector512<T> left, Vector512<T> right) => left == right; 1681public static bool EqualsAny<T>(Vector512<T> left, Vector512<T> right) 1689public static Vector512<double> Exp(Vector512<double> vector) 1693return VectorMath.ExpDouble<Vector512<double>, Vector512<ulong>>(vector); 1706public static Vector512<float> Exp(Vector512<float> vector) 1710return VectorMath.ExpSingle<Vector512<float>, Vector512<uint>, Vector512<double>, Vector512<ulong>>(vector); 1729public static ulong ExtractMostSignificantBits<T>(this Vector512<T> vector) 1741internal static Vector512<T> Floor<T>(Vector512<T> vector) 1770public static Vector512<float> Floor(Vector512<float> vector) => Floor<float>(vector); 1777public static Vector512<double> Floor(Vector512<double> vector) => Floor<double>(vector); 1782public static Vector512<double> FusedMultiplyAdd(Vector512<double> left, Vector512<double> right, Vector512<double> addend) 1793public static Vector512<float> FusedMultiplyAdd(Vector512<float> left, Vector512<float> right, Vector512<float> addend) 1810public static T GetElement<T>(this Vector512<T> vector, int index) 1812if ((uint)(index) >= (uint)(Vector512<T>.Count)) 1826public static Vector256<T> GetLower<T>(this Vector512<T> vector) 1838public static Vector256<T> GetUpper<T>(this Vector512<T> vector) 1852public static Vector512<T> GreaterThan<T>(Vector512<T> left, Vector512<T> right) 1868public static bool GreaterThanAll<T>(Vector512<T> left, Vector512<T> right) 1882public static bool GreaterThanAny<T>(Vector512<T> left, Vector512<T> right) 1896public static Vector512<T> GreaterThanOrEqual<T>(Vector512<T> left, Vector512<T> right) 1912public static bool GreaterThanOrEqualAll<T>(Vector512<T> left, Vector512<T> right) 1926public static bool GreaterThanOrEqualAny<T>(Vector512<T> left, Vector512<T> right) 1934public static Vector512<double> Hypot(Vector512<double> x, Vector512<double> y) 1938return VectorMath.HypotDouble<Vector512<double>, Vector512<ulong>>(x, y); 1951public static Vector512<float> Hypot(Vector512<float> x, Vector512<float> y) 1955return VectorMath.HypotSingle<Vector512<float>, Vector512<double>>(x, y); 1969public static int IndexOf<T>(Vector512<T> vector, T value) 1978public static int IndexOfWhereAllBitsSet<T>(Vector512<T> vector) 1997public static Vector512<T> IsEvenInteger<T>(Vector512<T> vector) 2001return VectorMath.IsEvenIntegerSingle<Vector512<float>, Vector512<uint>>(vector.AsSingle()).As<float, T>(); 2005return VectorMath.IsEvenIntegerDouble<Vector512<double>, Vector512<ulong>>(vector.AsDouble()).As<double, T>(); 2007return IsZero(vector & Vector512<T>.One); 2013public static Vector512<T> IsFinite<T>(Vector512<T> vector) 2023return Vector512<T>.AllBitsSet; 2029public static Vector512<T> IsInfinity<T>(Vector512<T> vector) 2035return Vector512<T>.Zero; 2041public static Vector512<T> IsInteger<T>(Vector512<T> vector) 2047return Vector512<T>.AllBitsSet; 2053public static Vector512<T> IsNaN<T>(Vector512<T> vector) 2059return Vector512<T>.Zero; 2065public static Vector512<T> IsNegative<T>(Vector512<T> vector) 2073return Vector512<T>.Zero; 2077return LessThan(vector.AsInt32(), Vector512<int>.Zero).As<int, T>(); 2081return LessThan(vector.AsInt64(), Vector512<long>.Zero).As<long, T>(); 2085return LessThan(vector, Vector512<T>.Zero); 2092public static Vector512<T> IsNegativeInfinity<T>(Vector512<T> vector) 2102return Vector512<T>.Zero; 2108public static Vector512<T> IsNormal<T>(Vector512<T> vector) 2124public static Vector512<T> IsOddInteger<T>(Vector512<T> vector) 2128return VectorMath.IsOddIntegerSingle<Vector512<float>, Vector512<uint>>(vector.AsSingle()).As<float, T>(); 2132return VectorMath.IsOddIntegerDouble<Vector512<double>, Vector512<ulong>>(vector.AsDouble()).As<double, T>(); 2134return ~IsZero(vector & Vector512<T>.One); 2140public static Vector512<T> IsPositive<T>(Vector512<T> vector) 2148return Vector512<T>.AllBitsSet; 2152return GreaterThanOrEqual(vector.AsInt32(), Vector512<int>.Zero).As<int, T>(); 2156return GreaterThanOrEqual(vector.AsInt64(), Vector512<long>.Zero).As<long, T>(); 2160return GreaterThanOrEqual(vector, Vector512<T>.Zero); 2167public static Vector512<T> IsPositiveInfinity<T>(Vector512<T> vector) 2177return Vector512<T>.Zero; 2183public static Vector512<T> IsSubnormal<T>(Vector512<T> vector) 2187return LessThan(Abs(vector).AsUInt32() - Vector512<uint>.One, Create<uint>(float.MaxTrailingSignificand)).As<uint, T>(); 2191return LessThan(Abs(vector).AsUInt64() - Vector512<ulong>.One, Create<ulong>(double.MaxTrailingSignificand)).As<ulong, T>(); 2193return Vector512<T>.Zero; 2199public static Vector512<T> IsZero<T>(Vector512<T> vector) => Equals(vector, Vector512<T>.Zero); 2204public static int LastIndexOf<T>(Vector512<T> vector, T value) => 63 - BitOperations.LeadingZeroCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 2209public static int LastIndexOfWhereAllBitsSet<T>(Vector512<T> vector) 2228public static Vector512<double> Lerp(Vector512<double> x, Vector512<double> y, Vector512<double> amount) 2232return VectorMath.Lerp<Vector512<double>, double>(x, y, amount); 2246public static Vector512<float> Lerp(Vector512<float> x, Vector512<float> y, Vector512<float> amount) 2250return VectorMath.Lerp<Vector512<float>, float>(x, y, amount); 2269public static Vector512<T> LessThan<T>(Vector512<T> left, Vector512<T> right) 2285public static bool LessThanAll<T>(Vector512<T> left, Vector512<T> right) 2299public static bool LessThanAny<T>(Vector512<T> left, Vector512<T> right) 2313public static Vector512<T> LessThanOrEqual<T>(Vector512<T> left, Vector512<T> right) 2329public static bool LessThanOrEqualAll<T>(Vector512<T> left, Vector512<T> right) 2343public static bool LessThanOrEqualAny<T>(Vector512<T> left, Vector512<T> right) 2356public static unsafe Vector512<T> Load<T>(T* source) => LoadUnsafe(ref *source); 2366public static unsafe Vector512<T> LoadAligned<T>(T* source) 2375return *(Vector512<T>*)(source); 2386public static unsafe Vector512<T> LoadAlignedNonTemporal<T>(T* source) => LoadAligned(source); 2395public static Vector512<T> LoadUnsafe<T>(ref readonly T source) 2399return Unsafe.ReadUnaligned<Vector512<T>>(in address); 2411public static Vector512<T> LoadUnsafe<T>(ref readonly T source, nuint elementOffset) 2415return Unsafe.ReadUnaligned<Vector512<T>>(in address); 2421internal static Vector512<ushort> LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source)); 2427internal static Vector512<ushort> LoadUnsafe(ref char source, nuint elementOffset) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source), elementOffset); 2431public static Vector512<double> Log(Vector512<double> vector) 2435return VectorMath.LogDouble<Vector512<double>, Vector512<long>, Vector512<ulong>>(vector); 2448public static Vector512<float> Log(Vector512<float> vector) 2452return VectorMath.LogSingle<Vector512<float>, Vector512<int>, Vector512<uint>>(vector); 2465public static Vector512<double> Log2(Vector512<double> vector) 2469return VectorMath.Log2Double<Vector512<double>, Vector512<long>, Vector512<ulong>>(vector); 2482public static Vector512<float> Log2(Vector512<float> vector) 2486return VectorMath.Log2Single<Vector512<float>, Vector512<int>, Vector512<uint>>(vector); 2500public static Vector512<T> Max<T>(Vector512<T> left, Vector512<T> right) 2504return VectorMath.Max<Vector512<T>, T>(left, right); 2518public static Vector512<T> MaxMagnitude<T>(Vector512<T> left, Vector512<T> right) 2522return VectorMath.MaxMagnitude<Vector512<T>, T>(left, right); 2536public static Vector512<T> MaxMagnitudeNumber<T>(Vector512<T> left, Vector512<T> right) 2540return VectorMath.MaxMagnitudeNumber<Vector512<T>, T>(left, right); 2554public static Vector512<T> MaxNative<T>(Vector512<T> left, Vector512<T> right) 2572public static Vector512<T> MaxNumber<T>(Vector512<T> left, Vector512<T> right) 2576return VectorMath.MaxNumber<Vector512<T>, T>(left, right); 2590public static Vector512<T> Min<T>(Vector512<T> left, Vector512<T> right) 2594return VectorMath.Min<Vector512<T>, T>(left, right); 2608public static Vector512<T> MinMagnitude<T>(Vector512<T> left, Vector512<T> right) 2612return VectorMath.MinMagnitude<Vector512<T>, T>(left, right); 2626public static Vector512<T> MinMagnitudeNumber<T>(Vector512<T> left, Vector512<T> right) 2630return VectorMath.MinMagnitudeNumber<Vector512<T>, T>(left, right); 2644public static Vector512<T> MinNative<T>(Vector512<T> left, Vector512<T> right) 2662public static Vector512<T> MinNumber<T>(Vector512<T> left, Vector512<T> right) 2666return VectorMath.MinNumber<Vector512<T>, T>(left, right); 2684public static Vector512<T> Multiply<T>(Vector512<T> left, Vector512<T> right) => left * right; 2693public static Vector512<T> Multiply<T>(Vector512<T> left, T right) => left * right; 2702public static Vector512<T> Multiply<T>(T left, Vector512<T> right) => right * left; 2706internal static Vector512<T> MultiplyAddEstimate<T>(Vector512<T> left, Vector512<T> right, Vector512<T> addend) 2717public static Vector512<double> MultiplyAddEstimate(Vector512<double> left, Vector512<double> right, Vector512<double> addend) 2727public static Vector512<float> MultiplyAddEstimate(Vector512<float> left, Vector512<float> right, Vector512<float> addend) 2737internal static Vector512<TResult> Narrow<TSource, TResult>(Vector512<TSource> lower, Vector512<TSource> upper) 2741Unsafe.SkipInit(out Vector512<TResult> result); 2743for (int i = 0; i < Vector512<TSource>.Count; i++) 2749for (int i = Vector512<TSource>.Count; i < Vector512<TResult>.Count; i++) 2751TResult value = TResult.CreateTruncating(upper.GetElementUnsafe(i - Vector512<TSource>.Count)); 2761public static Vector512<float> Narrow(Vector512<double> lower, Vector512<double> upper) 2768public static Vector512<sbyte> Narrow(Vector512<short> lower, Vector512<short> upper) 2774public static Vector512<short> Narrow(Vector512<int> lower, Vector512<int> upper) 2780public static Vector512<int> Narrow(Vector512<long> lower, Vector512<long> upper) 2787public static Vector512<byte> Narrow(Vector512<ushort> lower, Vector512<ushort> upper) 2794public static Vector512<ushort> Narrow(Vector512<uint> lower, Vector512<uint> upper) 2801public static Vector512<uint> Narrow(Vector512<ulong> lower, Vector512<ulong> upper) 2806internal static Vector512<TResult> NarrowWithSaturation<TSource, TResult>(Vector512<TSource> lower, Vector512<TSource> upper) 2810Unsafe.SkipInit(out Vector512<TResult> result); 2812for (int i = 0; i < Vector512<TSource>.Count; i++) 2818for (int i = Vector512<TSource>.Count; i < Vector512<TResult>.Count; i++) 2820TResult value = TResult.CreateSaturating(upper.GetElementUnsafe(i - Vector512<TSource>.Count)); 2830public static Vector512<float> NarrowWithSaturation(Vector512<double> lower, Vector512<double> upper) 2837public static Vector512<sbyte> NarrowWithSaturation(Vector512<short> lower, Vector512<short> upper) 2843public static Vector512<short> NarrowWithSaturation(Vector512<int> lower, Vector512<int> upper) 2849public static Vector512<int> NarrowWithSaturation(Vector512<long> lower, Vector512<long> upper) 2856public static Vector512<byte> NarrowWithSaturation(Vector512<ushort> lower, Vector512<ushort> upper) 2863public static Vector512<ushort> NarrowWithSaturation(Vector512<uint> lower, Vector512<uint> upper) 2870public static Vector512<uint> NarrowWithSaturation(Vector512<ulong> lower, Vector512<ulong> upper) 2879public static Vector512<T> Negate<T>(Vector512<T> vector) => -vector; 2884public static bool None<T>(Vector512<T> vector, T value) => !EqualsAny(vector, Create(value)); 2889public static bool NoneWhereAllBitsSet<T>(Vector512<T> vector) 2911public static Vector512<T> OnesComplement<T>(Vector512<T> vector) => ~vector; 2916public static Vector512<double> RadiansToDegrees(Vector512<double> radians) 2920return VectorMath.RadiansToDegrees<Vector512<double>, double>(radians); 2934public static Vector512<float> RadiansToDegrees(Vector512<float> radians) 2938return VectorMath.RadiansToDegrees<Vector512<float>, float>(radians); 2951internal static Vector512<T> Round<T>(Vector512<T> vector) 2977public static Vector512<double> Round(Vector512<double> vector) => Round<double>(vector); 2981public static Vector512<float> Round(Vector512<float> vector) => Round<float>(vector); 2985public static Vector512<double> Round(Vector512<double> vector, MidpointRounding mode) => VectorMath.RoundDouble(vector, mode); 2989public static Vector512<float> Round(Vector512<float> vector, MidpointRounding mode) => VectorMath.RoundSingle(vector, mode); 2996internal static Vector512<T> ShiftLeft<T>(Vector512<T> vector, int shiftCount) => vector << shiftCount; 3003public static Vector512<byte> ShiftLeft(Vector512<byte> vector, int shiftCount) => vector << shiftCount; 3010public static Vector512<short> ShiftLeft(Vector512<short> vector, int shiftCount) => vector << shiftCount; 3017public static Vector512<int> ShiftLeft(Vector512<int> vector, int shiftCount) => vector << shiftCount; 3024public static Vector512<long> ShiftLeft(Vector512<long> vector, int shiftCount) => vector << shiftCount; 3031public static Vector512<nint> ShiftLeft(Vector512<nint> vector, int shiftCount) => vector << shiftCount; 3039public static Vector512<nuint> ShiftLeft(Vector512<nuint> vector, int shiftCount) => vector << shiftCount; 3047public static Vector512<sbyte> ShiftLeft(Vector512<sbyte> vector, int shiftCount) => vector << shiftCount; 3055public static Vector512<ushort> ShiftLeft(Vector512<ushort> vector, int shiftCount) => vector << shiftCount; 3063public static Vector512<uint> ShiftLeft(Vector512<uint> vector, int shiftCount) => vector << shiftCount; 3066internal static Vector512<uint> ShiftLeft(Vector512<uint> vector, Vector512<uint> shiftCount) 3080public static Vector512<ulong> ShiftLeft(Vector512<ulong> vector, int shiftCount) => vector << shiftCount; 3083internal static Vector512<ulong> ShiftLeft(Vector512<ulong> vector, Vector512<ulong> shiftCount) 3096internal static Vector512<T> ShiftRightArithmetic<T>(Vector512<T> vector, int shiftCount) => vector >> shiftCount; 3103public static Vector512<short> ShiftRightArithmetic(Vector512<short> vector, int shiftCount) => vector >> shiftCount; 3110public static Vector512<int> ShiftRightArithmetic(Vector512<int> vector, int shiftCount) => vector >> shiftCount; 3117public static Vector512<long> ShiftRightArithmetic(Vector512<long> vector, int shiftCount) => vector >> shiftCount; 3124public static Vector512<nint> ShiftRightArithmetic(Vector512<nint> vector, int shiftCount) => vector >> shiftCount; 3132public static Vector512<sbyte> ShiftRightArithmetic(Vector512<sbyte> vector, int shiftCount) => vector >> shiftCount; 3139internal static Vector512<T> ShiftRightLogical<T>(Vector512<T> vector, int shiftCount) => vector >>> shiftCount; 3146public static Vector512<byte> ShiftRightLogical(Vector512<byte> vector, int shiftCount) => vector >>> shiftCount; 3153public static Vector512<short> ShiftRightLogical(Vector512<short> vector, int shiftCount) => vector >>> shiftCount; 3160public static Vector512<int> ShiftRightLogical(Vector512<int> vector, int shiftCount) => vector >>> shiftCount; 3167public static Vector512<long> ShiftRightLogical(Vector512<long> vector, int shiftCount) => vector >>> shiftCount; 3174public static Vector512<nint> ShiftRightLogical(Vector512<nint> vector, int shiftCount) => vector >>> shiftCount; 3182public static Vector512<nuint> ShiftRightLogical(Vector512<nuint> vector, int shiftCount) => vector >>> shiftCount; 3190public static Vector512<sbyte> ShiftRightLogical(Vector512<sbyte> vector, int shiftCount) => vector >>> shiftCount; 3198public static Vector512<ushort> ShiftRightLogical(Vector512<ushort> vector, int shiftCount) => vector >>> shiftCount; 3206public static Vector512<uint> ShiftRightLogical(Vector512<uint> vector, int shiftCount) => vector >>> shiftCount; 3214public static Vector512<ulong> ShiftRightLogical(Vector512<ulong> vector, int shiftCount) => vector >>> shiftCount; 3222internal static Vector512<byte> ShuffleNativeFallback(Vector512<byte> vector, Vector512<byte> indices) 3228internal static Vector512<sbyte> ShuffleNativeFallback(Vector512<sbyte> vector, Vector512<sbyte> indices) 3234internal static Vector512<short> ShuffleNativeFallback(Vector512<short> vector, Vector512<short> indices) 3240internal static Vector512<ushort> ShuffleNativeFallback(Vector512<ushort> vector, Vector512<ushort> indices) 3246internal static Vector512<int> ShuffleNativeFallback(Vector512<int> vector, Vector512<int> indices) 3252internal static Vector512<uint> ShuffleNativeFallback(Vector512<uint> vector, Vector512<uint> indices) 3258internal static Vector512<float> ShuffleNativeFallback(Vector512<float> vector, Vector512<int> indices) 3264internal static Vector512<long> ShuffleNativeFallback(Vector512<long> vector, Vector512<long> indices) 3270internal static Vector512<ulong> ShuffleNativeFallback(Vector512<ulong> vector, Vector512<ulong> indices) 3276internal static Vector512<double> ShuffleNativeFallback(Vector512<double> vector, Vector512<long> indices) 3287public static Vector512<byte> Shuffle(Vector512<byte> vector, Vector512<byte> indices) 3289Unsafe.SkipInit(out Vector512<byte> result); 3291for (int index = 0; index < Vector512<byte>.Count; index++) 3296if (selectedIndex < Vector512<byte>.Count) 3312public static Vector512<sbyte> Shuffle(Vector512<sbyte> vector, Vector512<sbyte> indices) 3314Unsafe.SkipInit(out Vector512<sbyte> result); 3316for (int index = 0; index < Vector512<sbyte>.Count; index++) 3321if (selectedIndex < Vector512<sbyte>.Count) 3342public static Vector512<byte> ShuffleNative(Vector512<byte> vector, Vector512<byte> indices) 3363public static Vector512<sbyte> ShuffleNative(Vector512<sbyte> vector, Vector512<sbyte> indices) 3377public static Vector512<short> Shuffle(Vector512<short> vector, Vector512<short> indices) 3379Unsafe.SkipInit(out Vector512<short> result); 3381for (int index = 0; index < Vector512<short>.Count; index++) 3386if (selectedIndex < Vector512<short>.Count) 3402public static Vector512<ushort> Shuffle(Vector512<ushort> vector, Vector512<ushort> indices) 3404Unsafe.SkipInit(out Vector512<ushort> result); 3406for (int index = 0; index < Vector512<ushort>.Count; index++) 3411if (selectedIndex < Vector512<ushort>.Count) 3431public static Vector512<short> ShuffleNative(Vector512<short> vector, Vector512<short> indices) 3451public static Vector512<ushort> ShuffleNative(Vector512<ushort> vector, Vector512<ushort> indices) 3465public static Vector512<int> Shuffle(Vector512<int> vector, Vector512<int> indices) 3467Unsafe.SkipInit(out Vector512<int> result); 3469for (int index = 0; index < Vector512<int>.Count; index++) 3474if (selectedIndex < Vector512<int>.Count) 3490public static Vector512<uint> Shuffle(Vector512<uint> vector, Vector512<uint> indices) 3492Unsafe.SkipInit(out Vector512<uint> result); 3494for (int index = 0; index < Vector512<uint>.Count; index++) 3499if (selectedIndex < Vector512<uint>.Count) 3514public static Vector512<float> Shuffle(Vector512<float> vector, Vector512<int> indices) 3516Unsafe.SkipInit(out Vector512<float> result); 3518for (int index = 0; index < Vector512<float>.Count; index++) 3523if (selectedIndex < Vector512<float>.Count) 3543public static Vector512<int> ShuffleNative(Vector512<int> vector, Vector512<int> indices) 3563public static Vector512<uint> ShuffleNative(Vector512<uint> vector, Vector512<uint> indices) 3582public static Vector512<float> ShuffleNative(Vector512<float> vector, Vector512<int> indices) 3596public static Vector512<long> Shuffle(Vector512<long> vector, Vector512<long> indices) 3598Unsafe.SkipInit(out Vector512<long> result); 3600for (int index = 0; index < Vector512<long>.Count; index++) 3605if (selectedIndex < (uint)Vector512<long>.Count) 3621public static Vector512<ulong> Shuffle(Vector512<ulong> vector, Vector512<ulong> indices) 3623Unsafe.SkipInit(out Vector512<ulong> result); 3625for (int index = 0; index < Vector512<ulong>.Count; index++) 3630if (selectedIndex < (uint)Vector512<ulong>.Count) 3645public static Vector512<double> Shuffle(Vector512<double> vector, Vector512<long> indices) 3647Unsafe.SkipInit(out Vector512<double> result); 3649for (int index = 0; index < Vector512<double>.Count; index++) 3654if (selectedIndex < (uint)Vector512<double>.Count) 3674public static Vector512<long> ShuffleNative(Vector512<long> vector, Vector512<long> indices) 3694public static Vector512<ulong> ShuffleNative(Vector512<ulong> vector, Vector512<ulong> indices) 3713public static Vector512<double> ShuffleNative(Vector512<double> vector, Vector512<long> indices) 3724public static Vector512<double> Sin(Vector512<double> vector) 3728return VectorMath.SinDouble<Vector512<double>, Vector512<long>>(vector); 3741public static Vector512<float> Sin(Vector512<float> vector) 3745return VectorMath.SinSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 3758public static (Vector512<double> Sin, Vector512<double> Cos) SinCos(Vector512<double> vector) 3762return VectorMath.SinCosDouble<Vector512<double>, Vector512<long>>(vector); 3778public static (Vector512<float> Sin, Vector512<float> Cos) SinCos(Vector512<float> vector) 3782return VectorMath.SinCosSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 3803public static Vector512<T> Sqrt<T>(Vector512<T> vector) 3818public static unsafe void Store<T>(this Vector512<T> source, T* destination) => source.StoreUnsafe(ref *destination); 3828public static unsafe void StoreAligned<T>(this Vector512<T> source, T* destination) 3837*(Vector512<T>*)(destination) = source; 3848public static unsafe void StoreAlignedNonTemporal<T>(this Vector512<T> source, T* destination) => source.StoreAligned(destination); 3857public static void StoreUnsafe<T>(this Vector512<T> source, ref T destination) 3873public static void StoreUnsafe<T>(this Vector512<T> source, ref T destination, nuint elementOffset) 3882public static Vector512<T> Subtract<T>(Vector512<T> left, Vector512<T> right) => left - right; 3887public static Vector512<T> SubtractSaturate<T>(Vector512<T> left, Vector512<T> right) 3909public static T Sum<T>(Vector512<T> vector) 3926public static T ToScalar<T>(this Vector512<T> vector) 3934internal static Vector512<T> Truncate<T>(Vector512<T> vector) 3960public static Vector512<double> Truncate(Vector512<double> vector) => Truncate<double>(vector); 3964public static Vector512<float> Truncate(Vector512<float> vector) => Truncate<float>(vector); 3970/// <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> 3972public static bool TryCopyTo<T>(this Vector512<T> vector, Span<T> destination) 3974if ((uint)destination.Length < (uint)Vector512<T>.Count) 3983/// <summary>Widens a <see langword="Vector512&lt;Byte&gt;" /> into two <see cref="Vector512{UInt16} " />.</summary> 3988public static (Vector512<ushort> Lower, Vector512<ushort> Upper) Widen(Vector512<byte> source) => (WidenLower(source), WidenUpper(source)); 3990/// <summary>Widens a <see langword="Vector512&lt;Int16&gt;" /> into two <see cref="Vector512{Int32} " />.</summary> 3994public static (Vector512<int> Lower, Vector512<int> Upper) Widen(Vector512<short> source) => (WidenLower(source), WidenUpper(source)); 3996/// <summary>Widens a <see langword="Vector512&lt;Int32&gt;" /> into two <see cref="Vector512{Int64} " />.</summary> 4000public static (Vector512<long> Lower, Vector512<long> Upper) Widen(Vector512<int> source) => (WidenLower(source), WidenUpper(source)); 4002/// <summary>Widens a <see langword="Vector512&lt;SByte&gt;" /> into two <see cref="Vector512{Int16} " />.</summary> 4007public static (Vector512<short> Lower, Vector512<short> Upper) Widen(Vector512<sbyte> source) => (WidenLower(source), WidenUpper(source)); 4009/// <summary>Widens a <see langword="Vector512&lt;Single&gt;" /> into two <see cref="Vector512{Double} " />.</summary> 4013public static (Vector512<double> Lower, Vector512<double> Upper) Widen(Vector512<float> source) => (WidenLower(source), WidenUpper(source)); 4015/// <summary>Widens a <see langword="Vector512&lt;UInt16&gt;" /> into two <see cref="Vector512{UInt32} " />.</summary> 4020public static (Vector512<uint> Lower, Vector512<uint> Upper) Widen(Vector512<ushort> source) => (WidenLower(source), WidenUpper(source)); 4022/// <summary>Widens a <see langword="Vector512&lt;UInt32&gt;" /> into two <see cref="Vector512{UInt64} " />.</summary> 4027public static (Vector512<ulong> Lower, Vector512<ulong> Upper) Widen(Vector512<uint> source) => (WidenLower(source), WidenUpper(source)); 4029/// <summary>Widens the lower half of a <see langword="Vector512&lt;Byte&gt;" /> into a <see cref="Vector512{UInt16} " />.</summary> 4035public static Vector512<ushort> WidenLower(Vector512<byte> source) 4045/// <summary>Widens the lower half of a <see langword="Vector512&lt;Int16&gt;" /> into a <see cref="Vector512{Int32} " />.</summary> 4050public static Vector512<int> WidenLower(Vector512<short> source) 4060/// <summary>Widens the lower half of a <see langword="Vector512&lt;Int32&gt;" /> into a <see cref="Vector512{Int64} " />.</summary> 4065public static Vector512<long> WidenLower(Vector512<int> source) 4075/// <summary>Widens the lower half of a <see langword="Vector512&lt;SByte&gt;" /> into a <see cref="Vector512{Int16} " />.</summary> 4081public static Vector512<short> WidenLower(Vector512<sbyte> source) 4090/// <summary>Widens the lower half of a <see langword="Vector512&lt;Single&gt;" /> into a <see cref="Vector512{Double} " />.</summary> 4095public static Vector512<double> WidenLower(Vector512<float> source) 4105/// <summary>Widens the lower half of a <see langword="Vector512&lt;UInt16&gt;" /> into a <see cref="Vector512{UInt32} " />.</summary> 4111public static Vector512<uint> WidenLower(Vector512<ushort> source) 4121/// <summary>Widens the lower half of a <see langword="Vector512&lt;UInt32&gt;" /> into a <see cref="Vector512{UInt64} " />.</summary> 4127public static Vector512<ulong> WidenLower(Vector512<uint> source) 4137/// <summary>Widens the upper half of a <see langword="Vector512&lt;Byte&gt;" /> into a <see cref="Vector512{UInt16} " />.</summary> 4143public static Vector512<ushort> WidenUpper(Vector512<byte> source) 4153/// <summary>Widens the upper half of a <see langword="Vector512&lt;Int16&gt;" /> into a <see cref="Vector512{Int32} " />.</summary> 4158public static Vector512<int> WidenUpper(Vector512<short> source) 4168/// <summary>Widens the upper half of a <see langword="Vector512&lt;Int32&gt;" /> into a <see cref="Vector512{Int64} " />.</summary> 4173public static Vector512<long> WidenUpper(Vector512<int> source) 4183/// <summary>Widens the upper half of a <see langword="Vector512&lt;SByte&gt;" /> into a <see cref="Vector512{Int16} " />.</summary> 4189public static Vector512<short> WidenUpper(Vector512<sbyte> source) 4199/// <summary>Widens the upper half of a <see langword="Vector512&lt;Single&gt;" /> into a <see cref="Vector512{Double} " />.</summary> 4204public static Vector512<double> WidenUpper(Vector512<float> source) 4214/// <summary>Widens the upper half of a <see langword="Vector512&lt;UInt16&gt;" /> into a <see cref="Vector512{UInt32} " />.</summary> 4220public static Vector512<uint> WidenUpper(Vector512<ushort> source) 4230/// <summary>Widens the upper half of a <see langword="Vector512&lt;UInt32&gt;" /> into a <see cref="Vector512{UInt64} " />.</summary> 4236public static Vector512<ulong> WidenUpper(Vector512<uint> source) 4246/// <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> 4251/// <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> 4255public static Vector512<T> WithElement<T>(this Vector512<T> vector, int index, T value) 4257if ((uint)(index) >= (uint)(Vector512<T>.Count)) 4262Vector512<T> result = vector; 4267/// <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> 4271/// <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> 4275public static Vector512<T> WithLower<T>(this Vector512<T> vector, Vector256<T> value) 4279Vector512<T> result = vector; 4284/// <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> 4288/// <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> 4292public static Vector512<T> WithUpper<T>(this Vector512<T> vector, Vector256<T> value) 4296Vector512<T> result = vector; 4308public static Vector512<T> Xor<T>(Vector512<T> left, Vector512<T> right) => left ^ right; 4311internal static T GetElementUnsafe<T>(in this Vector512<T> vector, int index) 4313Debug.Assert((index >= 0) && (index < Vector512<T>.Count)); 4314ref T address = ref Unsafe.As<Vector512<T>, T>(ref Unsafe.AsRef(in vector)); 4319internal static void SetElementUnsafe<T>(in this Vector512<T> vector, int index, T value) 4321Debug.Assert((index >= 0) && (index < Vector512<T>.Count)); 4322ref T address = ref Unsafe.As<Vector512<T>, T>(ref Unsafe.AsRef(in vector)); 4326internal static void SetLowerUnsafe<T>(in this Vector512<T> vector, Vector256<T> value) => Unsafe.AsRef(in vector._lower) = value; 4328internal static void SetUpperUnsafe<T>(in this Vector512<T> vector, Vector256<T> value) => Unsafe.AsRef(in vector._upper) = value;

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

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];

2376else if (typeof(TVectorInt64) == typeof(Vector512<long>)) 2378result = (TVectorDouble)(object)Vector512.ConvertToDouble((Vector512<long>)(object)vector); 2411else if (typeof(TVectorInt32) == typeof(Vector512<int>)) 2413result = (TVectorSingle)(object)Vector512.ConvertToSingle((Vector512<int>)(object)vector); 2535else if (typeof(TVector) == typeof(Vector512<double>)) 2569else if (typeof(TVector) == typeof(Vector512<float>)) 2616else if (typeof(TVectorDouble) == typeof(Vector512<double>)) 2622result = (TVectorSingle)(object)Avx512F.ConvertToVector256Single((Vector512<double>)(object)vector); 2626Vector512<double> value = (Vector512<double>)(object)vector; 2665else if (typeof(TVectorDouble) == typeof(Vector512<double>)) 2667Debug.Assert(typeof(TVectorSingle) == typeof(Vector512<float>)); 2668result = (TVectorSingle)(object)Vector512.Narrow((Vector512<double>)(object)lower, (Vector512<double>)(object)upper); 2712else if (typeof(TVectorUInt32) == typeof(Vector512<uint>)) 2715(Vector512<uint>)(object)vector, 2716(Vector512<uint>)(object)shiftAmount 2761else if (typeof(TVectorUInt64) == typeof(Vector512<ulong>)) 2764(Vector512<ulong>)(object)vector, 2765(Vector512<ulong>)(object)shiftAmount 2939Debug.Assert(typeof(TVectorDouble) == typeof(Vector512<double>)); 2990else if (typeof(TVectorSingle) == typeof(Vector512<float>)) 2992Debug.Assert(typeof(TVectorDouble) == typeof(Vector512<double>)); 2993result = (TVectorDouble)(object)Vector512.WidenLower((Vector512<float>)(object)vector); 3030else if (typeof(TVectorSingle) == typeof(Vector512<float>)) 3032Debug.Assert(typeof(TVectorDouble) == typeof(Vector512<double>)); 3033result = (TVectorDouble)(object)Vector512.WidenUpper((Vector512<float>)(object)vector);

3966public static Vector512<float> And(Vector512<float> left, Vector512<float> right) => And(left, right); 3971public static Vector512<double> And(Vector512<double> left, Vector512<double> right) => And(left, right); 3977public static Vector512<float> AndNot(Vector512<float> left, Vector512<float> right) => AndNot(left, right); 3982public static Vector512<double> AndNot(Vector512<double> left, Vector512<double> right) => AndNot(left, right); 3988public static Vector512<int> BroadcastPairScalarToVector512(Vector128<int> value) => BroadcastPairScalarToVector512(value); 3993public static Vector512<uint> BroadcastPairScalarToVector512(Vector128<uint> value) => BroadcastPairScalarToVector512(value); 3998public static Vector512<float> BroadcastPairScalarToVector512(Vector128<float> value) => BroadcastPairScalarToVector512(value); 4004public static unsafe Vector512<long> BroadcastVector128ToVector512(long* address) => BroadcastVector128ToVector512(address); 4009public static unsafe Vector512<ulong> BroadcastVector128ToVector512(ulong* address) => BroadcastVector128ToVector512(address); 4014public static unsafe Vector512<double> BroadcastVector128ToVector512(double* address) => BroadcastVector128ToVector512(address); 4020public static unsafe Vector512<int> BroadcastVector256ToVector512(int* address) => BroadcastVector256ToVector512(address); 4025public static unsafe Vector512<uint> BroadcastVector256ToVector512(uint* address) => BroadcastVector256ToVector512(address); 4030public static unsafe Vector512<float> BroadcastVector256ToVector512(float* address) => BroadcastVector256ToVector512(address); 4036public static Vector512<double> Classify(Vector512<double> value, [ConstantExpected] byte control) => Classify(value, control); 4041public static Vector512<float> Classify(Vector512<float> value, [ConstantExpected] byte control) => Classify(value, control); 4047public static Vector512<byte> Compress(Vector512<byte> merge, Vector512<byte> mask, Vector512<byte> value) => Compress(merge, mask, value); 4052public static Vector512<short> Compress(Vector512<short> merge, Vector512<short> mask, Vector512<short> value) => Compress(merge, mask, value); 4057public static Vector512<sbyte> Compress(Vector512<sbyte> merge, Vector512<sbyte> mask, Vector512<sbyte> value) => Compress(merge, mask, value); 4062public static Vector512<ushort> Compress(Vector512<ushort> merge, Vector512<ushort> mask, Vector512<ushort> value) => Compress(merge, mask, value); 4068public static unsafe void CompressStore(byte* address, Vector512<byte> mask, Vector512<byte> source) => CompressStore(address, mask, source); 4073public static unsafe void CompressStore(short* address, Vector512<short> mask, Vector512<short> source) => CompressStore(address, mask, source); 4078public static unsafe void CompressStore(sbyte* address, Vector512<sbyte> mask, Vector512<sbyte> source) => CompressStore(address, mask, source); 4083public static unsafe void CompressStore(ushort* address, Vector512<ushort> mask, Vector512<ushort> source) => CompressStore(address, mask, source); 4089public static Vector256<float> ConvertToVector256Single(Vector512<long> value) => ConvertToVector256Single(value); 4094public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value) => ConvertToVector256Single(value); 4099public static Vector256<float> ConvertToVector256Single(Vector512<long> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); 4104public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); 4110public static Vector512<double> ConvertToVector512Double(Vector512<long> value) => ConvertToVector512Double(value); 4115public static Vector512<double> ConvertToVector512Double(Vector512<ulong> value) => ConvertToVector512Double(value); 4120public static Vector512<double> ConvertToVector512Double(Vector512<long> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Double(value, mode); 4125public static Vector512<double> ConvertToVector512Double(Vector512<ulong> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Double(value, mode); 4131public static Vector512<long> ConvertToVector512Int64(Vector256<float> value) => ConvertToVector512Int64(value); 4136public static Vector512<long> ConvertToVector512Int64(Vector512<double> value) => ConvertToVector512Int64(value); 4141public static Vector512<long> ConvertToVector512Int64(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int64(value, mode); 4146public static Vector512<long> ConvertToVector512Int64(Vector512<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int64(value, mode); 4152public static Vector512<long> ConvertToVector512Int64WithTruncation(Vector256<float> value) => ConvertToVector512Int64WithTruncation(value); 4157public static Vector512<long> ConvertToVector512Int64WithTruncation(Vector512<double> value) => ConvertToVector512Int64WithTruncation(value); 4163public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value) => ConvertToVector512UInt64(value); 4168public static Vector512<ulong> ConvertToVector512UInt64(Vector512<double> value) => ConvertToVector512UInt64(value); 4173public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt64(value, mode); 4178public static Vector512<ulong> ConvertToVector512UInt64(Vector512<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt64(value, mode); 4184public static Vector512<ulong> ConvertToVector512UInt64WithTruncation(Vector256<float> value) => ConvertToVector512UInt64WithTruncation(value); 4189public static Vector512<ulong> ConvertToVector512UInt64WithTruncation(Vector512<double> value) => ConvertToVector512UInt64WithTruncation(value); 4195public static Vector512<int> DetectConflicts(Vector512<int> value) => DetectConflicts(value); 4200public static Vector512<uint> DetectConflicts(Vector512<uint> value) => DetectConflicts(value); 4205public static Vector512<long> DetectConflicts(Vector512<long> value) => DetectConflicts(value); 4210public static Vector512<ulong> DetectConflicts(Vector512<ulong> value) => DetectConflicts(value); 4216public static Vector512<byte> Expand(Vector512<byte> merge, Vector512<byte> mask, Vector512<byte> value) => Expand(merge, mask, value); 4221public static Vector512<short> Expand(Vector512<short> merge, Vector512<short> mask, Vector512<short> value) => Expand(merge, mask, value); 4226public static Vector512<sbyte> Expand(Vector512<sbyte> merge, Vector512<sbyte> mask, Vector512<sbyte> value) => Expand(merge, mask, value); 4231public static Vector512<ushort> Expand(Vector512<ushort> merge, Vector512<ushort> mask, Vector512<ushort> value) => Expand(merge, mask, value); 4238public static unsafe Vector512<byte> ExpandLoad(byte* address, Vector512<byte> mask, Vector512<byte> merge) => ExpandLoad(address, mask, merge); 4244public static unsafe Vector512<short> ExpandLoad(short* address, Vector512<short> mask, Vector512<short> merge) => ExpandLoad(address, mask, merge); 4250public static unsafe Vector512<sbyte> ExpandLoad(sbyte* address, Vector512<sbyte> mask, Vector512<sbyte> merge) => ExpandLoad(address, mask, merge); 4256public static unsafe Vector512<ushort> ExpandLoad(ushort* address, Vector512<ushort> mask, Vector512<ushort> merge) => ExpandLoad(address, mask, merge); 4262public static new Vector128<long> ExtractVector128(Vector512<long> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 4267public static new Vector128<ulong> ExtractVector128(Vector512<ulong> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 4272public static new Vector128<double> ExtractVector128(Vector512<double> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 4278public static new Vector256<int> ExtractVector256(Vector512<int> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 4283public static new Vector256<uint> ExtractVector256(Vector512<uint> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 4288public static new Vector256<float> ExtractVector256(Vector512<float> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 4294public static new Vector512<long> InsertVector128(Vector512<long> value, Vector128<long> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 4299public static new Vector512<ulong> InsertVector128(Vector512<ulong> value, Vector128<ulong> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 4304public static new Vector512<double> InsertVector128(Vector512<double> value, Vector128<double> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 4310public static new Vector512<int> InsertVector256(Vector512<int> value, Vector256<int> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4315public static new Vector512<uint> InsertVector256(Vector512<uint> value, Vector256<uint> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4320public static new Vector512<float> InsertVector256(Vector512<float> value, Vector256<float> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4326public static Vector512<int> LeadingZeroCount(Vector512<int> value) => LeadingZeroCount(value); 4331public static Vector512<uint> LeadingZeroCount(Vector512<uint> value) => LeadingZeroCount(value); 4336public static Vector512<long> LeadingZeroCount(Vector512<long> value) => LeadingZeroCount(value); 4341public static Vector512<ulong> LeadingZeroCount(Vector512<ulong> value) => LeadingZeroCount(value); 4347public static int MoveMask(Vector512<double> value) => MoveMask(value); 4352public static int MoveMask(Vector512<long> value) => MoveMask(value); 4357public static int MoveMask(Vector512<ulong> value) => MoveMask(value); 4363public static Vector512<long> MultiplyLow(Vector512<long> left, Vector512<long> right) => MultiplyLow(left, right); 4368public static Vector512<ulong> MultiplyLow(Vector512<ulong> left, Vector512<ulong> right) => MultiplyLow(left, right); 4374public static Vector512<byte> MultiShift(Vector512<byte> control, Vector512<ulong> value) => MultiShift(control, value); 4379public static Vector512<sbyte> MultiShift(Vector512<sbyte> control, Vector512<long> value) => MultiShift(control, value); 4385public static Vector512<float> Or(Vector512<float> left, Vector512<float> right) => Or(left, right); 4390public static Vector512<double> Or(Vector512<double> left, Vector512<double> right) => Or(left, right); 4397public static Vector512<sbyte> PermuteVar64x8(Vector512<sbyte> left, Vector512<sbyte> control) => PermuteVar64x8(left, control); 4403public static Vector512<byte> PermuteVar64x8(Vector512<byte> left, Vector512<byte> control) => PermuteVar64x8(left, control); 4410public static Vector512<byte> PermuteVar64x8x2(Vector512<byte> lower, Vector512<byte> indices, Vector512<byte> upper) => PermuteVar64x8x2(lower, indices, upper); 4416public static Vector512<sbyte> PermuteVar64x8x2(Vector512<sbyte> lower, Vector512<sbyte> indices, Vector512<sbyte> upper) => PermuteVar64x8x2(lower, indices, upper); 4422public static Vector512<float> Range(Vector512<float> left, Vector512<float> right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); 4427public static Vector512<double> Range(Vector512<double> left, Vector512<double> right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); 4433public static Vector512<float> Reduce(Vector512<float> value, [ConstantExpected] byte control) => Reduce(value, control); 4438public static Vector512<double> Reduce(Vector512<double> value, [ConstantExpected] byte control) => Reduce(value, control); 4444public static Vector512<float> Xor(Vector512<float> left, Vector512<float> right) => Xor(left, right); 4449public static Vector512<double> Xor(Vector512<double> left, Vector512<double> right) => Xor(left, right);

147public static Vector512<double> MinMax(Vector512<double> left, Vector512<double> right, [ConstantExpected] byte control) => MinMax(left, right, control); 152public static Vector512<float> MinMax(Vector512<float> left, Vector512<float> right, [ConstantExpected] byte control) => MinMax(left, right, control); 157public static Vector512<int> ConvertToSByteWithSaturationAndZeroExtendToInt32(Vector512<float> value) => ConvertToSByteWithSaturationAndZeroExtendToInt32(value); 162public static Vector512<int> ConvertToSByteWithSaturationAndZeroExtendToInt32(Vector512<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToSByteWithSaturationAndZeroExtendToInt32(value, mode); 167public static Vector512<int> ConvertToByteWithSaturationAndZeroExtendToInt32(Vector512<float> value) => ConvertToByteWithSaturationAndZeroExtendToInt32(value); 172public static Vector512<int> ConvertToByteWithSaturationAndZeroExtendToInt32(Vector512<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToByteWithSaturationAndZeroExtendToInt32(value, mode); 177public static Vector512<int> ConvertToSByteWithTruncatedSaturationAndZeroExtendToInt32(Vector512<float> value) => ConvertToSByteWithTruncatedSaturationAndZeroExtendToInt32(value); 182public static Vector512<int> ConvertToByteWithTruncatedSaturationAndZeroExtendToInt32(Vector512<float> value) => ConvertToByteWithTruncatedSaturationAndZeroExtendToInt32(value); 187public static Vector512<ushort> MultipleSumAbsoluteDifferences(Vector512<byte> left, Vector512<byte> right, [ConstantExpected] byte mask) => MultipleSumAbsoluteDifferences(left, right, mask);

617public static Vector512<byte> Abs(Vector512<sbyte> value) => Abs(value); 622public static Vector512<ushort> Abs(Vector512<short> value) => Abs(value); 628public static Vector512<sbyte> Add(Vector512<sbyte> left, Vector512<sbyte> right) => Add(left, right); 633public static Vector512<byte> Add(Vector512<byte> left, Vector512<byte> right) => Add(left, right); 638public static Vector512<short> Add(Vector512<short> left, Vector512<short> right) => Add(left, right); 643public static Vector512<ushort> Add(Vector512<ushort> left, Vector512<ushort> right) => Add(left, right); 649public static Vector512<sbyte> AddSaturate(Vector512<sbyte> left, Vector512<sbyte> right) => AddSaturate(left, right); 654public static Vector512<byte> AddSaturate(Vector512<byte> left, Vector512<byte> right) => AddSaturate(left, right); 659public static Vector512<short> AddSaturate(Vector512<short> left, Vector512<short> right) => AddSaturate(left, right); 664public static Vector512<ushort> AddSaturate(Vector512<ushort> left, Vector512<ushort> right) => AddSaturate(left, right); 670public static Vector512<sbyte> AlignRight(Vector512<sbyte> left, Vector512<sbyte> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); 675public static Vector512<byte> AlignRight(Vector512<byte> left, Vector512<byte> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); 681public static Vector512<byte> Average(Vector512<byte> left, Vector512<byte> right) => Average(left, right); 686public static Vector512<ushort> Average(Vector512<ushort> left, Vector512<ushort> right) => Average(left, right); 693public static Vector512<byte> BlendVariable(Vector512<byte> left, Vector512<byte> right, Vector512<byte> mask) => BlendVariable(left, right, mask); 699public static Vector512<short> BlendVariable(Vector512<short> left, Vector512<short> right, Vector512<short> mask) => BlendVariable(left, right, mask); 705public static Vector512<sbyte> BlendVariable(Vector512<sbyte> left, Vector512<sbyte> right, Vector512<sbyte> mask) => BlendVariable(left, right, mask); 711public static Vector512<ushort> BlendVariable(Vector512<ushort> left, Vector512<ushort> right, Vector512<ushort> mask) => BlendVariable(left, right, mask); 717public static Vector512<byte> BroadcastScalarToVector512(Vector128<byte> value) => BroadcastScalarToVector512(value); 722public static Vector512<sbyte> BroadcastScalarToVector512(Vector128<sbyte> value) => BroadcastScalarToVector512(value); 727public static Vector512<short> BroadcastScalarToVector512(Vector128<short> value) => BroadcastScalarToVector512(value); 732public static Vector512<ushort> BroadcastScalarToVector512(Vector128<ushort> value) => BroadcastScalarToVector512(value); 738public static Vector512<byte> CompareEqual(Vector512<byte> left, Vector512<byte> right) => CompareEqual(left, right); 743public static Vector512<byte> CompareGreaterThan(Vector512<byte> left, Vector512<byte> right) => CompareGreaterThan(left, right); 748public static Vector512<byte> CompareGreaterThanOrEqual(Vector512<byte> left, Vector512<byte> right) => CompareGreaterThanOrEqual(left, right); 753public static Vector512<byte> CompareLessThan(Vector512<byte> left, Vector512<byte> right) => CompareLessThan(left, right); 758public static Vector512<byte> CompareLessThanOrEqual(Vector512<byte> left, Vector512<byte> right) => CompareLessThanOrEqual(left, right); 763public static Vector512<byte> CompareNotEqual(Vector512<byte> left, Vector512<byte> right) => CompareNotEqual(left, right); 769public static Vector512<short> CompareEqual(Vector512<short> left, Vector512<short> right) => CompareEqual(left, right); 774public static Vector512<short> CompareGreaterThan(Vector512<short> left, Vector512<short> right) => CompareGreaterThan(left, right); 779public static Vector512<short> CompareGreaterThanOrEqual(Vector512<short> left, Vector512<short> right) => CompareGreaterThanOrEqual(left, right); 784public static Vector512<short> CompareLessThan(Vector512<short> left, Vector512<short> right) => CompareLessThan(left, right); 789public static Vector512<short> CompareLessThanOrEqual(Vector512<short> left, Vector512<short> right) => CompareLessThanOrEqual(left, right); 794public static Vector512<short> CompareNotEqual(Vector512<short> left, Vector512<short> right) => CompareNotEqual(left, right); 800public static Vector512<sbyte> CompareEqual(Vector512<sbyte> left, Vector512<sbyte> right) => CompareEqual(left, right); 805public static Vector512<sbyte> CompareGreaterThan(Vector512<sbyte> left, Vector512<sbyte> right) => CompareGreaterThan(left, right); 810public static Vector512<sbyte> CompareGreaterThanOrEqual(Vector512<sbyte> left, Vector512<sbyte> right) => CompareGreaterThanOrEqual(left, right); 815public static Vector512<sbyte> CompareLessThan(Vector512<sbyte> left, Vector512<sbyte> right) => CompareLessThan(left, right); 820public static Vector512<sbyte> CompareLessThanOrEqual(Vector512<sbyte> left, Vector512<sbyte> right) => CompareLessThanOrEqual(left, right); 825public static Vector512<sbyte> CompareNotEqual(Vector512<sbyte> left, Vector512<sbyte> right) => CompareNotEqual(left, right); 831public static Vector512<ushort> CompareEqual(Vector512<ushort> left, Vector512<ushort> right) => CompareEqual(left, right); 836public static Vector512<ushort> CompareGreaterThan(Vector512<ushort> left, Vector512<ushort> right) => CompareGreaterThan(left, right); 841public static Vector512<ushort> CompareGreaterThanOrEqual(Vector512<ushort> left, Vector512<ushort> right) => CompareGreaterThanOrEqual(left, right); 846public static Vector512<ushort> CompareLessThan(Vector512<ushort> left, Vector512<ushort> right) => CompareLessThan(left, right); 851public static Vector512<ushort> CompareLessThanOrEqual(Vector512<ushort> left, Vector512<ushort> right) => CompareLessThanOrEqual(left, right); 856public static Vector512<ushort> CompareNotEqual(Vector512<ushort> left, Vector512<ushort> right) => CompareNotEqual(left, right); 862public static Vector256<byte> ConvertToVector256Byte(Vector512<short> value) => ConvertToVector256Byte(value); 867public static Vector256<byte> ConvertToVector256Byte(Vector512<ushort> value) => ConvertToVector256Byte(value); 872public static Vector256<byte> ConvertToVector256ByteWithSaturation(Vector512<ushort> value) => ConvertToVector256ByteWithSaturation(value); 878public static Vector256<sbyte> ConvertToVector256SByte(Vector512<short> value) => ConvertToVector256SByte(value); 883public static Vector256<sbyte> ConvertToVector256SByte(Vector512<ushort> value) => ConvertToVector256SByte(value); 888public static Vector256<sbyte> ConvertToVector256SByteWithSaturation(Vector512<short> value) => ConvertToVector256SByteWithSaturation(value); 894public static Vector512<short> ConvertToVector512Int16(Vector256<sbyte> value) => ConvertToVector512Int16(value); 899public static Vector512<short> ConvertToVector512Int16(Vector256<byte> value) => ConvertToVector512Int16(value); 904public static Vector512<ushort> ConvertToVector512UInt16(Vector256<sbyte> value) => ConvertToVector512UInt16(value); 909public static Vector512<ushort> ConvertToVector512UInt16(Vector256<byte> value) => ConvertToVector512UInt16(value); 915public static new unsafe Vector512<sbyte> LoadVector512(sbyte* address) => LoadVector512(address); 920public static new unsafe Vector512<byte> LoadVector512(byte* address) => LoadVector512(address); 925public static new unsafe Vector512<short> LoadVector512(short* address) => LoadVector512(address); 930public static new unsafe Vector512<ushort> LoadVector512(ushort* address) => LoadVector512(address); 937public static unsafe Vector512<byte> MaskLoad(byte* address, Vector512<byte> mask, Vector512<byte> merge) => MaskLoad(address, mask, merge); 943public static unsafe Vector512<short> MaskLoad(short* address, Vector512<short> mask, Vector512<short> merge) => MaskLoad(address, mask, merge); 949public static unsafe Vector512<sbyte> MaskLoad(sbyte* address, Vector512<sbyte> mask, Vector512<sbyte> merge) => MaskLoad(address, mask, merge); 955public static unsafe Vector512<ushort> MaskLoad(ushort* address, Vector512<ushort> mask, Vector512<ushort> merge) => MaskLoad(address, mask, merge); 961public static unsafe void MaskStore(byte* address, Vector512<byte> mask, Vector512<byte> source) => MaskStore(address, mask, source); 966public static unsafe void MaskStore(short* address, Vector512<short> mask, Vector512<short> source) => MaskStore(address, mask, source); 971public static unsafe void MaskStore(sbyte* address, Vector512<sbyte> mask, Vector512<sbyte> source) => MaskStore(address, mask, source); 976public static unsafe void MaskStore(ushort* address, Vector512<ushort> mask, Vector512<ushort> source) => MaskStore(address, mask, source); 982public static Vector512<sbyte> Max(Vector512<sbyte> left, Vector512<sbyte> right) => Max(left, right); 987public static Vector512<byte> Max(Vector512<byte> left, Vector512<byte> right) => Max(left, right); 992public static Vector512<short> Max(Vector512<short> left, Vector512<short> right) => Max(left, right); 997public static Vector512<ushort> Max(Vector512<ushort> left, Vector512<ushort> right) => Max(left, right); 1003public static Vector512<sbyte> Min(Vector512<sbyte> left, Vector512<sbyte> right) => Min(left, right); 1008public static Vector512<byte> Min(Vector512<byte> left, Vector512<byte> right) => Min(left, right); 1013public static Vector512<short> Min(Vector512<short> left, Vector512<short> right) => Min(left, right); 1018public static Vector512<ushort> Min(Vector512<ushort> left, Vector512<ushort> right) => Min(left, right); 1035public static long MoveMask(Vector512<byte> value) => MoveMask(value); 1040public static int MoveMask(Vector512<short> value) => MoveMask(value); 1045public static long MoveMask(Vector512<sbyte> value) => MoveMask(value); 1050public static int MoveMask(Vector512<ushort> value) => MoveMask(value); 1056public static Vector512<int> MultiplyAddAdjacent(Vector512<short> left, Vector512<short> right) => MultiplyAddAdjacent(left, right); 1061public static Vector512<short> MultiplyAddAdjacent(Vector512<byte> left, Vector512<sbyte> right) => MultiplyAddAdjacent(left, right); 1067public static Vector512<short> MultiplyHigh(Vector512<short> left, Vector512<short> right) => MultiplyHigh(left, right); 1072public static Vector512<ushort> MultiplyHigh(Vector512<ushort> left, Vector512<ushort> right) => MultiplyHigh(left, right); 1078public static Vector512<short> MultiplyHighRoundScale(Vector512<short> left, Vector512<short> right) => MultiplyHighRoundScale(left, right); 1084public static Vector512<short> MultiplyLow(Vector512<short> left, Vector512<short> right) => MultiplyLow(left, right); 1089public static Vector512<ushort> MultiplyLow(Vector512<ushort> left, Vector512<ushort> right) => MultiplyLow(left, right); 1095public static Vector512<sbyte> PackSignedSaturate(Vector512<short> left, Vector512<short> right) => PackSignedSaturate(left, right); 1100public static Vector512<short> PackSignedSaturate(Vector512<int> left, Vector512<int> right) => PackSignedSaturate(left, right); 1106public static Vector512<byte> PackUnsignedSaturate(Vector512<short> left, Vector512<short> right) => PackUnsignedSaturate(left, right); 1111public static Vector512<ushort> PackUnsignedSaturate(Vector512<int> left, Vector512<int> right) => PackUnsignedSaturate(left, right); 1118public static Vector512<short> PermuteVar32x16(Vector512<short> left, Vector512<short> control) => PermuteVar32x16(left, control); 1124public static Vector512<ushort> PermuteVar32x16(Vector512<ushort> left, Vector512<ushort> control) => PermuteVar32x16(left, control); 1131public static Vector512<short> PermuteVar32x16x2(Vector512<short> lower, Vector512<short> indices, Vector512<short> upper) => PermuteVar32x16x2(lower, indices, upper); 1137public static Vector512<ushort> PermuteVar32x16x2(Vector512<ushort> lower, Vector512<ushort> indices, Vector512<ushort> upper) => PermuteVar32x16x2(lower, indices, upper); 1143public static Vector512<short> ShiftLeftLogical(Vector512<short> value, Vector128<short> count) => ShiftLeftLogical(value, count); 1148public static Vector512<ushort> ShiftLeftLogical(Vector512<ushort> value, Vector128<ushort> count) => ShiftLeftLogical(value, count); 1154public static Vector512<short> ShiftLeftLogical(Vector512<short> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); 1159public static Vector512<ushort> ShiftLeftLogical(Vector512<ushort> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); 1165public static Vector512<sbyte> ShiftLeftLogical128BitLane(Vector512<sbyte> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); 1170public static Vector512<byte> ShiftLeftLogical128BitLane(Vector512<byte> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); 1176public static Vector512<short> ShiftLeftLogicalVariable(Vector512<short> value, Vector512<ushort> count) => ShiftLeftLogicalVariable(value, count); 1181public static Vector512<ushort> ShiftLeftLogicalVariable(Vector512<ushort> value, Vector512<ushort> count) => ShiftLeftLogicalVariable(value, count); 1187public static Vector512<short> ShiftRightArithmetic(Vector512<short> value, Vector128<short> count) => ShiftRightArithmetic(value, count); 1193public static Vector512<short> ShiftRightArithmetic(Vector512<short> value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); 1199public static Vector512<short> ShiftRightArithmeticVariable(Vector512<short> value, Vector512<ushort> count) => ShiftRightArithmeticVariable(value, count); 1205public static Vector512<short> ShiftRightLogical(Vector512<short> value, Vector128<short> count) => ShiftRightLogical(value, count); 1210public static Vector512<ushort> ShiftRightLogical(Vector512<ushort> value, Vector128<ushort> count) => ShiftRightLogical(value, count); 1216public static Vector512<short> ShiftRightLogical(Vector512<short> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); 1221public static Vector512<ushort> ShiftRightLogical(Vector512<ushort> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); 1227public static Vector512<sbyte> ShiftRightLogical128BitLane(Vector512<sbyte> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); 1232public static Vector512<byte> ShiftRightLogical128BitLane(Vector512<byte> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); 1238public static Vector512<short> ShiftRightLogicalVariable(Vector512<short> value, Vector512<ushort> count) => ShiftRightLogicalVariable(value, count); 1243public static Vector512<ushort> ShiftRightLogicalVariable(Vector512<ushort> value, Vector512<ushort> count) => ShiftRightLogicalVariable(value, count); 1249public static Vector512<sbyte> Shuffle(Vector512<sbyte> value, Vector512<sbyte> mask) => Shuffle(value, mask); 1254public static Vector512<byte> Shuffle(Vector512<byte> value, Vector512<byte> mask) => Shuffle(value, mask); 1260public static Vector512<short> ShuffleHigh(Vector512<short> value, [ConstantExpected] byte control) => ShuffleHigh(value, control); 1265public static Vector512<ushort> ShuffleHigh(Vector512<ushort> value, [ConstantExpected] byte control) => ShuffleHigh(value, control); 1271public static Vector512<short> ShuffleLow(Vector512<short> value, [ConstantExpected] byte control) => ShuffleLow(value, control); 1276public static Vector512<ushort> ShuffleLow(Vector512<ushort> value, [ConstantExpected] byte control) => ShuffleLow(value, control); 1282public static new unsafe void Store(sbyte* address, Vector512<sbyte> source) => Store(address, source); 1287public static new unsafe void Store(byte* address, Vector512<byte> source) => Store(address, source); 1292public static new unsafe void Store(short* address, Vector512<short> source) => Store(address, source); 1297public static new unsafe void Store(ushort* address, Vector512<ushort> source) => Store(address, source); 1303public static Vector512<sbyte> Subtract(Vector512<sbyte> left, Vector512<sbyte> right) => Subtract(left, right); 1308public static Vector512<byte> Subtract(Vector512<byte> left, Vector512<byte> right) => Subtract(left, right); 1313public static Vector512<short> Subtract(Vector512<short> left, Vector512<short> right) => Subtract(left, right); 1318public static Vector512<ushort> Subtract(Vector512<ushort> left, Vector512<ushort> right) => Subtract(left, right); 1324public static Vector512<sbyte> SubtractSaturate(Vector512<sbyte> left, Vector512<sbyte> right) => SubtractSaturate(left, right); 1329public static Vector512<short> SubtractSaturate(Vector512<short> left, Vector512<short> right) => SubtractSaturate(left, right); 1334public static Vector512<byte> SubtractSaturate(Vector512<byte> left, Vector512<byte> right) => SubtractSaturate(left, right); 1339public static Vector512<ushort> SubtractSaturate(Vector512<ushort> left, Vector512<ushort> right) => SubtractSaturate(left, right); 1345public static Vector512<ushort> SumAbsoluteDifferences(Vector512<byte> left, Vector512<byte> right) => SumAbsoluteDifferences(left, right); 1351public static Vector512<ushort> SumAbsoluteDifferencesInBlock32(Vector512<byte> left, Vector512<byte> right, [ConstantExpected] byte control) => SumAbsoluteDifferencesInBlock32(left, right, control); 1357public static Vector512<sbyte> UnpackHigh(Vector512<sbyte> left, Vector512<sbyte> right) => UnpackHigh(left, right); 1362public static Vector512<byte> UnpackHigh(Vector512<byte> left, Vector512<byte> right) => UnpackHigh(left, right); 1367public static Vector512<short> UnpackHigh(Vector512<short> left, Vector512<short> right) => UnpackHigh(left, right); 1372public static Vector512<ushort> UnpackHigh(Vector512<ushort> left, Vector512<ushort> right) => UnpackHigh(left, right); 1378public static Vector512<sbyte> UnpackLow(Vector512<sbyte> left, Vector512<sbyte> right) => UnpackLow(left, right); 1383public static Vector512<byte> UnpackLow(Vector512<byte> left, Vector512<byte> right) => UnpackLow(left, right); 1388public static Vector512<short> UnpackLow(Vector512<short> left, Vector512<short> right) => UnpackLow(left, right); 1393public static Vector512<ushort> UnpackLow(Vector512<ushort> left, Vector512<ushort> right) => UnpackLow(left, right);