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

21static abstract Vector512<T> Invoke(Vector512<T> x); 30static abstract bool ShouldEarlyExit(Vector512<T> result); 42public static bool ShouldEarlyExit(Vector512<T> result) => Vector512.AnyWhereAllBitsSet(result); 77public static bool ShouldEarlyExit(Vector512<T> result) => 78typeof(T) == typeof(float) ? Vector512.EqualsAny(result.AsUInt32(), Vector512<uint>.Zero) : 79typeof(T) == typeof(double) ? Vector512.EqualsAny(result.AsUInt64(), Vector512<ulong>.Zero) : 80Vector512.EqualsAny(result, Vector512<T>.Zero); 100if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 102oneVectorFromEnd = x.Length - Vector512<T>.Count; 113i += Vector512<T>.Count; 119TAnyAll.ShouldEarlyExit(TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count))))) 234if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 236int vectorFromEnd = x.Length - Vector512<T>.Count; 243i += Vector512<T>.Count; 250i = x.Length - Vector512<T>.Count; 258Vector512<byte> v = TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i)).AsByte(); 260(v & Vector512<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i); 342if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 344int vectorsFromEnd = x.Length - (Vector512<T>.Count * sizeof(T)); 351i += Vector512<T>.Count * sizeof(T); 358i = x.Length - (Vector512<T>.Count * sizeof(T)); 366Vector512<byte> v = 369TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<T>.Count))).AsUInt16()); 371(v & Vector512<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i); 459if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 461int vectorsFromEnd = x.Length - (Vector512<T>.Count * sizeof(T)); 468i += Vector512<T>.Count * sizeof(T); 475i = x.Length - (Vector512<T>.Count * sizeof(T)); 483Vector512<byte> v = 487TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<T>.Count))).AsUInt32()), 489TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (2 * Vector512<T>.Count)))).AsUInt32(), 490TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (3 * Vector512<T>.Count)))).AsUInt32())); 492(v & Vector512<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i); 586if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 590int vectorsFromEnd = x.Length - (Vector512<T>.Count * sizeof(T)); 597i += Vector512<T>.Count * sizeof(T); 604i = x.Length - (Vector512<T>.Count * sizeof(T)); 612Vector512<byte> v = 617TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<T>.Count))).AsUInt64()), 619TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (2 * Vector512<T>.Count)))).AsUInt64(), 620TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (3 * Vector512<T>.Count)))).AsUInt64())), 623TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (4 * Vector512<T>.Count)))).AsUInt64(), 624TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (5 * Vector512<T>.Count)))).AsUInt64()), 626TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (6 * Vector512<T>.Count)))).AsUInt64(), 627TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + (7 * Vector512<T>.Count)))).AsUInt64()))); 629(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);

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

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

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

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

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

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

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

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

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

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

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

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)

225public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> min, Vector512<T> max) => Vector512.Clamp(x, min, max); 273public static Vector512<T> Invoke(Vector512<T> min, Vector512<T> max, Vector512<T> x) => Vector512.Clamp(x, min, max); 322public static Vector512<T> Invoke(Vector512<T> max, Vector512<T> x, Vector512<T> min) => Vector512.Clamp(x, min, max);

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

143public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) 161public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x); 196private static Vector512<T> IsNaN<T>(Vector512<T> vector) 271private static Vector512<T> IsNegative<T>(Vector512<T> vector) 361private static Vector512<T> IsPositive<T>(Vector512<T> vector) 407if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 413Vector512<T> result = Vector512.LoadUnsafe(ref xRef, 0); 414Vector512<T> current; 416Vector512<T> nanMask; 421if (nanMask != Vector512<T>.Zero) 427int oneVectorFromEnd = x.Length - Vector512<T>.Count; 428int i = Vector512<T>.Count; 440if (nanMask != Vector512<T>.Zero) 447i += Vector512<T>.Count; 453current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 459if (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);

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

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

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

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

227public static Vector512<T> Invoke(Vector512<T> x) 290public static Vector512<T> Invoke(Vector512<T> x) 346public Vector512<T> Invoke(Vector512<T> x) 348Vector512<T> limit = Vector512.Create(typeof(T) == typeof(float) ? T.CreateTruncating(Single_RoundLimit) : T.CreateTruncating(Double_RoundLimit)); 368public Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

174for (; i <= (uint)values.Length - Vector512<byte>.Count; i += (uint)Vector512<byte>.Count) 176Vector512<byte> vector = Vector512.LoadUnsafe(ref value, i); 177Vector512<byte> isFalse = Vector512.Equals(vector, Vector512<byte>.Zero); 426i = Apply<Vector512<byte>>(count, thisArray, valueArray); 741if (Avx512BW.IsSupported && (uint)_bitLength >= Vector512<byte>.Count) 746Vector512<byte> shuffleMask = Vector512.Create(lowerShuffleMask_CopyToBoolArray256, upperShuffleMask_CopyToBoolArray256); 747Vector512<byte> bitMask = Vector512.Create(0x80402010_08040201).AsByte(); 748Vector512<byte> ones = Vector512<byte>.One; 752for (; (i + Vector512<byte>.Count) <= (uint)_bitLength; i += (uint)Vector512<byte>.Count) 755Vector512<ulong> scalar = Vector512.Create(bits); 756Vector512<byte> shuffled = Avx512BW.Shuffle(scalar.AsByte(), shuffleMask); 757Vector512<byte> extracted = Avx512F.And(shuffled, bitMask); 761Vector512<byte> normalized = Avx512BW.Min(extracted, ones);

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

474if (Vector<double>.Count == Vector512<double>.Count) 497if (Vector<double>.Count == Vector512<double>.Count) 605if (Vector<float>.Count == Vector512<float>.Count) 772if (Vector<T>.Count == Vector512<T>.Count) 1429if (Vector<T>.Count == Vector512<T>.Count) 1675if (Vector<T>.Count == Vector512<T>.Count) 2726if (Vector<uint>.Count == Vector512<uint>.Count) 2752if (Vector<ulong>.Count == Vector512<ulong>.Count)

841return VectorMath.CosSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 1746return VectorMath.ExpSingle<Vector256<float>, Vector256<uint>, Vector512<double>, Vector512<ulong>>(vector); 1998return VectorMath.HypotSingle<Vector256<float>, Vector512<double>>(x, y); 3796return VectorMath.SinSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 3840return VectorMath.SinCosSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 3995/// <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> 3998/// <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> 4001public static Vector512<T> ToVector512<T>(this Vector256<T> vector) 4005Vector512<T> result = default; 4010/// <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> 4013/// <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> 4016public static Vector512<T> ToVector512Unsafe<T>(this Vector256<T> vector) 4023Unsafe.SkipInit(out Vector512<T> result);

55extension<T>(Vector512<T>) 59public static Vector512<T> E 66public static Vector512<T> Pi 73public static Vector512<T> Tau 81extension<T>(Vector512<T>) 85public static Vector512<T> Epsilon 92public static Vector512<T> NaN 99public static Vector512<T> NegativeInfinity 106public static Vector512<T> NegativeZero 113public static Vector512<T> PositiveInfinity 121extension<T>(Vector512<T>) 125public static Vector512<T> NegativeOne 139public static Vector512<T> Abs<T>(Vector512<T> vector) 160public static Vector512<T> Add<T>(Vector512<T> left, Vector512<T> right) => left + right; 165public static Vector512<T> AddSaturate<T>(Vector512<T> left, Vector512<T> right) 183public static bool All<T>(Vector512<T> vector, T value) => vector == Create(value); 188public static bool AllWhereAllBitsSet<T>(Vector512<T> vector) 212public static Vector512<T> AndNot<T>(Vector512<T> left, Vector512<T> right) => left & ~right; 217public static bool Any<T>(Vector512<T> vector, T value) => EqualsAny(vector, Create(value)); 222public static bool AnyWhereAllBitsSet<T>(Vector512<T> vector) 246public static Vector512<TTo> As<TFrom, TTo>(this Vector512<TFrom> vector) 251return Unsafe.BitCast<Vector512<TFrom>, Vector512<TTo>>(vector); 254/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Byte&gt;" />.</summary> 260public static Vector512<byte> AsByte<T>(this Vector512<T> vector) => vector.As<T, byte>(); 262/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Double&gt;" />.</summary> 268public static Vector512<double> AsDouble<T>(this Vector512<T> vector) => vector.As<T, double>(); 270/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Int16&gt;" />.</summary> 276public static Vector512<short> AsInt16<T>(this Vector512<T> vector) => vector.As<T, short>(); 278/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Int32&gt;" />.</summary> 284public static Vector512<int> AsInt32<T>(this Vector512<T> vector) => vector.As<T, int>(); 286/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Int64&gt;" />.</summary> 292public static Vector512<long> AsInt64<T>(this Vector512<T> vector) => vector.As<T, long>(); 294/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;IntPtr&gt;" />.</summary> 300public static Vector512<nint> AsNInt<T>(this Vector512<T> vector) => vector.As<T, nint>(); 302/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UIntPtr&gt;" />.</summary> 309public static Vector512<nuint> AsNUInt<T>(this Vector512<T> vector) => vector.As<T, nuint>(); 311/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;SByte&gt;" />.</summary> 318public static Vector512<sbyte> AsSByte<T>(this Vector512<T> vector) => vector.As<T, sbyte>(); 320/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Single&gt;" />.</summary> 326public static Vector512<float> AsSingle<T>(this Vector512<T> vector) => vector.As<T, float>(); 328/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UInt16&gt;" />.</summary> 335public static Vector512<ushort> AsUInt16<T>(this Vector512<T> vector) => vector.As<T, ushort>(); 337/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UInt32&gt;" />.</summary> 344public static Vector512<uint> AsUInt32<T>(this Vector512<T> vector) => vector.As<T, uint>(); 346/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UInt64&gt;" />.</summary> 353public static Vector512<ulong> AsUInt64<T>(this Vector512<T> vector) => vector.As<T, ulong>(); 355/// <summary>Reinterprets a <see cref="Vector{T}" /> as a new <see cref="Vector512{T}" />.</summary> 358/// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector512{T}" />.</returns> 362public static Vector512<T> AsVector512<T>(this Vector<T> value) 364Debug.Assert(Vector512<T>.Count >= Vector<T>.Count); 367Vector512<T> result = default; 368Unsafe.WriteUnaligned(ref Unsafe.As<Vector512<T>, byte>(ref result), value); 372/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see cref="Vector{T}" />.</summary> 379public static Vector<T> AsVector<T>(this Vector512<T> value) 381Debug.Assert(Vector512<T>.Count >= Vector<T>.Count); 384ref byte address = ref Unsafe.As<Vector512<T>, byte>(ref value); 395public static Vector512<T> BitwiseAnd<T>(Vector512<T> left, Vector512<T> right) => left & right; 404public static Vector512<T> BitwiseOr<T>(Vector512<T> left, Vector512<T> right) => left | right; 411internal static Vector512<T> Ceiling<T>(Vector512<T> vector) 440public static Vector512<float> Ceiling(Vector512<float> vector) => Ceiling<float>(vector); 447public static Vector512<double> Ceiling(Vector512<double> vector) => Ceiling<double>(vector); 451public static Vector512<T> Clamp<T>(Vector512<T> value, Vector512<T> min, Vector512<T> max) 459public static Vector512<T> ClampNative<T>(Vector512<T> value, Vector512<T> min, Vector512<T> max) 475public static Vector512<T> ConditionalSelect<T>(Vector512<T> condition, Vector512<T> left, Vector512<T> right) => (left & condition) | AndNot(right, condition); 482public static Vector512<double> ConvertToDouble(Vector512<long> vector) 496public static Vector512<double> ConvertToDouble(Vector512<ulong> vector) 509public static Vector512<int> ConvertToInt32(Vector512<float> vector) 522public static Vector512<int> ConvertToInt32Native(Vector512<float> vector) 535public static Vector512<long> ConvertToInt64(Vector512<double> vector) 548public static Vector512<long> ConvertToInt64Native(Vector512<double> vector) 561public static Vector512<float> ConvertToSingle(Vector512<int> vector) 575public static Vector512<float> ConvertToSingle(Vector512<uint> vector) 589public static Vector512<uint> ConvertToUInt32(Vector512<float> vector) 603public static Vector512<uint> ConvertToUInt32Native(Vector512<float> vector) 617public static Vector512<ulong> ConvertToUInt64(Vector512<double> vector) 631public static Vector512<ulong> ConvertToUInt64Native(Vector512<double> vector) 642public static Vector512<T> CopySign<T>(Vector512<T> value, Vector512<T> sign) 654return VectorMath.CopySign<Vector512<T>, T>(value, sign); 665/// <summary>Copies a <see cref="Vector512{T}" /> to a given array.</summary> 669/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</exception> 672public static void CopyTo<T>(this Vector512<T> vector, T[] destination) 676if (destination.Length < Vector512<T>.Count) 684/// <summary>Copies a <see cref="Vector512{T}" /> to a given array starting at the specified index.</summary> 689/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</exception> 693public static void CopyTo<T>(this Vector512<T> vector, T[] destination, int startIndex) 702if ((destination.Length - startIndex) < Vector512<T>.Count) 710/// <summary>Copies a <see cref="Vector512{T}" /> to a given span.</summary> 714/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</exception> 716public static void CopyTo<T>(this Vector512<T> vector, Span<T> destination) 718if ((uint)destination.Length < (uint)Vector512<T>.Count) 728public static Vector512<double> Cos(Vector512<double> vector) 732return VectorMath.CosDouble<Vector512<double>, Vector512<long>>(vector); 745public static Vector512<float> Cos(Vector512<float> vector) 749return VectorMath.CosSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 763public static int Count<T>(Vector512<T> vector, T value) => BitOperations.PopCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 768public static int CountWhereAllBitsSet<T>(Vector512<T> vector) 784/// <summary>Creates a new <see cref="Vector512{T}" /> instance with all elements initialized to the specified value.</summary> 787/// <returns>A new <see cref="Vector512{T}" /> with all elements initialized to <paramref name="value" />.</returns> 790public static Vector512<T> Create<T>(T value) 801public static Vector512<byte> Create(byte value) => Create<byte>(value); 808public static Vector512<double> Create(double value) => Create<double>(value); 815public static Vector512<short> Create(short value) => Create<short>(value); 822public static Vector512<int> Create(int value) => Create<int>(value); 829public static Vector512<long> Create(long value) => Create<long>(value); 835public static Vector512<nint> Create(nint value) => Create<nint>(value); 842public static Vector512<nuint> Create(nuint value) => Create<nuint>(value); 850public static Vector512<sbyte> Create(sbyte value) => Create<sbyte>(value); 857public static Vector512<float> Create(float value) => Create<float>(value); 865public static Vector512<ushort> Create(ushort value) => Create<ushort>(value); 873public static Vector512<uint> Create(uint value) => Create<uint>(value); 881public static Vector512<ulong> Create(ulong value) => Create<ulong>(value); 883/// <summary>Creates a new <see cref="Vector512{T}" /> from a given array.</summary> 886/// <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> 887/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" /> is less than <see cref="Vector512{T}.Count" />.</exception> 890public static Vector512<T> Create<T>(T[] values) 894if (values.Length < Vector512<T>.Count) 899return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref values[0])); 902/// <summary>Creates a new <see cref="Vector512{T}" /> from a given array.</summary> 906/// <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> 907/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" />, starting from <paramref name="index" />, is less than <see cref="Vector512{T}.Count" />.</exception> 910public static Vector512<T> Create<T>(T[] values, int index) 914if ((index < 0) || ((values.Length - index) < Vector512<T>.Count)) 919return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref values[index])); 922/// <summary>Creates a new <see cref="Vector512{T}" /> from a given readonly span.</summary> 925/// <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> 926/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" /> is less than <see cref="Vector512{T}.Count" />.</exception> 929public static Vector512<T> Create<T>(ReadOnlySpan<T> values) 931if (values.Length < Vector512<T>.Count) 936return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 1008public 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, 1032public static Vector512<double> Create(double e0, double e1, double e2, double e3, double e4, double e5, double e6, double e7) 1077public 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, 1107public 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) 1128public static Vector512<long> Create(long e0, long e1, long e2, long e3, long e4, long e5, long e6, long e7) 1206public 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, 1238public 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) 1284public 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, 1315public 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) 1337public static Vector512<ulong> Create(ulong e0, ulong e1, ulong e2, ulong e3, ulong e4, ulong e5, ulong e6, ulong e7) 1345/// <summary>Creates a new <see cref="Vector512{T}" /> instance with all 64-bit parts initialized to a specified value.</summary> 1351public static Vector512<T> Create<T>(Vector64<T> value) => Create(Vector128.Create(value, value)); 1353/// <summary>Creates a new <see cref="Vector512{T}" /> instance with all 128-bit parts initialized to a specified value.</summary> 1359public static Vector512<T> Create<T>(Vector128<T> value) => Create(Vector256.Create(value, value)); 1361/// <summary>Creates a new <see cref="Vector512{T}" /> instance with the lower and upper 256-bits initialized to a specified value.</summary> 1367public static Vector512<T> Create<T>(Vector256<T> value) => Create(value, value); 1369/// <summary>Creates a new <see cref="Vector512{T}" /> instance from two <see cref="Vector256{T}" /> instances.</summary> 1373/// <returns>A new <see cref="Vector512{T}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns> 1376public static Vector512<T> Create<T>(Vector256<T> lower, Vector256<T> upper) 1379Unsafe.SkipInit(out Vector512<T> result); 1391public static Vector512<byte> Create(Vector256<byte> lower, Vector256<byte> upper) => Create<byte>(lower, upper); 1398public static Vector512<double> Create(Vector256<double> lower, Vector256<double> upper) => Create<double>(lower, upper); 1404public static Vector512<short> Create(Vector256<short> lower, Vector256<short> upper) => Create<short>(lower, upper); 1411public static Vector512<int> Create(Vector256<int> lower, Vector256<int> upper) => Create<int>(lower, upper); 1417public static Vector512<long> Create(Vector256<long> lower, Vector256<long> upper) => Create<long>(lower, upper); 1423public static Vector512<nint> Create(Vector256<nint> lower, Vector256<nint> upper) => Create<nint>(lower, upper); 1430public static Vector512<nuint> Create(Vector256<nuint> lower, Vector256<nuint> upper) => Create<nuint>(lower, upper); 1437public static Vector512<sbyte> Create(Vector256<sbyte> lower, Vector256<sbyte> upper) => Create<sbyte>(lower, upper); 1444public static Vector512<float> Create(Vector256<float> lower, Vector256<float> upper) => Create<float>(lower, upper); 1451public static Vector512<ushort> Create(Vector256<ushort> lower, Vector256<ushort> upper) => Create<ushort>(lower, upper); 1459public static Vector512<uint> Create(Vector256<uint> lower, Vector256<uint> upper) => Create<uint>(lower, upper); 1466public static Vector512<ulong> Create(Vector256<ulong> lower, Vector256<ulong> upper) => Create<ulong>(lower, upper); 1468/// <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> 1471/// <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> 1474public static Vector512<T> CreateScalar<T>(T value) => Vector256.CreateScalar(value).ToVector512(); 1480public static Vector512<byte> CreateScalar(byte value) => CreateScalar<byte>(value); 1486public static Vector512<double> CreateScalar(double value) => CreateScalar<double>(value); 1492public static Vector512<short> CreateScalar(short value) => CreateScalar<short>(value); 1498public static Vector512<int> CreateScalar(int value) => CreateScalar<int>(value); 1504public static Vector512<long> CreateScalar(long value) => CreateScalar<long>(value); 1510public static Vector512<nint> CreateScalar(nint value) => CreateScalar<nint>(value); 1517public static Vector512<nuint> CreateScalar(nuint value) => CreateScalar<nuint>(value); 1524public static Vector512<sbyte> CreateScalar(sbyte value) => CreateScalar<sbyte>(value); 1530public static Vector512<float> CreateScalar(float value) => CreateScalar<float>(value); 1537public static Vector512<ushort> CreateScalar(ushort value) => CreateScalar<ushort>(value); 1544public static Vector512<uint> CreateScalar(uint value) => CreateScalar<uint>(value); 1551public static Vector512<ulong> CreateScalar(ulong value) => CreateScalar<ulong>(value); 1553/// <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> 1556/// <returns>A new <see cref="Vector512{T}" /> instance with the first element initialized to <paramref name="value" /> and the remaining elements left uninitialized.</returns> 1560public static Vector512<T> CreateScalarUnsafe<T>(T value) 1566Unsafe.SkipInit(out Vector512<T> result); 1576public static Vector512<byte> CreateScalarUnsafe(byte value) => CreateScalarUnsafe<byte>(value); 1582public static Vector512<double> CreateScalarUnsafe(double value) => CreateScalarUnsafe<double>(value); 1588public static Vector512<short> CreateScalarUnsafe(short value) => CreateScalarUnsafe<short>(value); 1594public static Vector512<int> CreateScalarUnsafe(int value) => CreateScalarUnsafe<int>(value); 1600public static Vector512<long> CreateScalarUnsafe(long value) => CreateScalarUnsafe<long>(value); 1606public static Vector512<nint> CreateScalarUnsafe(nint value) => CreateScalarUnsafe<nint>(value); 1613public static Vector512<nuint> CreateScalarUnsafe(nuint value) => CreateScalarUnsafe<nuint>(value); 1620public static Vector512<sbyte> CreateScalarUnsafe(sbyte value) => CreateScalarUnsafe<sbyte>(value); 1626public static Vector512<float> CreateScalarUnsafe(float value) => CreateScalarUnsafe<float>(value); 1633public static Vector512<ushort> CreateScalarUnsafe(ushort value) => CreateScalarUnsafe<ushort>(value); 1640public static Vector512<uint> CreateScalarUnsafe(uint value) => CreateScalarUnsafe<uint>(value); 1647public static Vector512<ulong> CreateScalarUnsafe(ulong value) => CreateScalarUnsafe<ulong>(value); 1649/// <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> 1653/// <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> 1656public static Vector512<T> CreateSequence<T>(T start, T step) => (Vector512<T>.Indices * step) + Create(start); 1661public static Vector512<double> DegreesToRadians(Vector512<double> degrees) 1665return VectorMath.DegreesToRadians<Vector512<double>, double>(degrees); 1679public static Vector512<float> DegreesToRadians(Vector512<float> degrees) 1683return VectorMath.DegreesToRadians<Vector512<float>, float>(degrees); 1702public static Vector512<T> Divide<T>(Vector512<T> left, Vector512<T> right) => left / right; 1710public static Vector512<T> Divide<T>(Vector512<T> left, T right) => left / right; 1720public static T Dot<T>(Vector512<T> left, Vector512<T> right) => Sum(left * right); 1730public static Vector512<T> Equals<T>(Vector512<T> left, Vector512<T> right) 1745public static bool EqualsAll<T>(Vector512<T> left, Vector512<T> right) => left == right; 1755public static bool EqualsAny<T>(Vector512<T> left, Vector512<T> right) 1763public static Vector512<double> Exp(Vector512<double> vector) 1767return VectorMath.ExpDouble<Vector512<double>, Vector512<ulong>>(vector); 1780public static Vector512<float> Exp(Vector512<float> vector) 1784return VectorMath.ExpSingle<Vector512<float>, Vector512<uint>, Vector512<double>, Vector512<ulong>>(vector); 1803public static ulong ExtractMostSignificantBits<T>(this Vector512<T> vector) 1815internal static Vector512<T> Floor<T>(Vector512<T> vector) 1844public static Vector512<float> Floor(Vector512<float> vector) => Floor<float>(vector); 1851public static Vector512<double> Floor(Vector512<double> vector) => Floor<double>(vector); 1856public static Vector512<double> FusedMultiplyAdd(Vector512<double> left, Vector512<double> right, Vector512<double> addend) 1867public static Vector512<float> FusedMultiplyAdd(Vector512<float> left, Vector512<float> right, Vector512<float> addend) 1884public static T GetElement<T>(this Vector512<T> vector, int index) 1886if ((uint)(index) >= (uint)(Vector512<T>.Count)) 1900public static Vector256<T> GetLower<T>(this Vector512<T> vector) 1912public static Vector256<T> GetUpper<T>(this Vector512<T> vector) 1926public static Vector512<T> GreaterThan<T>(Vector512<T> left, Vector512<T> right) 1942public static bool GreaterThanAll<T>(Vector512<T> left, Vector512<T> right) 1956public static bool GreaterThanAny<T>(Vector512<T> left, Vector512<T> right) 1970public static Vector512<T> GreaterThanOrEqual<T>(Vector512<T> left, Vector512<T> right) 1986public static bool GreaterThanOrEqualAll<T>(Vector512<T> left, Vector512<T> right) 2000public static bool GreaterThanOrEqualAny<T>(Vector512<T> left, Vector512<T> right) 2008public static Vector512<double> Hypot(Vector512<double> x, Vector512<double> y) 2012return VectorMath.HypotDouble<Vector512<double>, Vector512<ulong>>(x, y); 2025public static Vector512<float> Hypot(Vector512<float> x, Vector512<float> y) 2029return VectorMath.HypotSingle<Vector512<float>, Vector512<double>>(x, y); 2043public static int IndexOf<T>(Vector512<T> vector, T value) 2052public static int IndexOfWhereAllBitsSet<T>(Vector512<T> vector) 2071public static Vector512<T> IsEvenInteger<T>(Vector512<T> vector) 2075return VectorMath.IsEvenIntegerSingle<Vector512<float>, Vector512<uint>>(vector.AsSingle()).As<float, T>(); 2079return VectorMath.IsEvenIntegerDouble<Vector512<double>, Vector512<ulong>>(vector.AsDouble()).As<double, T>(); 2081return IsZero(vector & Vector512<T>.One); 2087public static Vector512<T> IsFinite<T>(Vector512<T> vector) 2091return ~IsZero(AndNot(Vector512<float>.PositiveInfinity.AsUInt32(), vector.AsUInt32())).As<uint, T>(); 2095return ~IsZero(AndNot(Vector512<double>.PositiveInfinity.AsUInt64(), vector.AsUInt64())).As<ulong, T>(); 2097return Vector512<T>.AllBitsSet; 2103public static Vector512<T> IsInfinity<T>(Vector512<T> vector) 2109return Vector512<T>.Zero; 2115public static Vector512<T> IsInteger<T>(Vector512<T> vector) 2121return Vector512<T>.AllBitsSet; 2127public static Vector512<T> IsNaN<T>(Vector512<T> vector) 2133return Vector512<T>.Zero; 2139public static Vector512<T> IsNegative<T>(Vector512<T> vector) 2147return Vector512<T>.Zero; 2151return LessThan(vector.AsInt32(), Vector512<int>.Zero).As<int, T>(); 2155return LessThan(vector.AsInt64(), Vector512<long>.Zero).As<long, T>(); 2159return LessThan(vector, Vector512<T>.Zero); 2166public static Vector512<T> IsNegativeInfinity<T>(Vector512<T> vector) 2170return Equals(vector, Vector512<float>.NegativeInfinity.As<float, T>()); 2174return Equals(vector, Vector512<double>.NegativeInfinity.As<double, T>()); 2176return Vector512<T>.Zero; 2182public static Vector512<T> IsNormal<T>(Vector512<T> vector) 2198public static Vector512<T> IsOddInteger<T>(Vector512<T> vector) 2202return VectorMath.IsOddIntegerSingle<Vector512<float>, Vector512<uint>>(vector.AsSingle()).As<float, T>(); 2206return VectorMath.IsOddIntegerDouble<Vector512<double>, Vector512<ulong>>(vector.AsDouble()).As<double, T>(); 2208return ~IsZero(vector & Vector512<T>.One); 2214public static Vector512<T> IsPositive<T>(Vector512<T> vector) 2222return Vector512<T>.AllBitsSet; 2226return GreaterThanOrEqual(vector.AsInt32(), Vector512<int>.Zero).As<int, T>(); 2230return GreaterThanOrEqual(vector.AsInt64(), Vector512<long>.Zero).As<long, T>(); 2234return GreaterThanOrEqual(vector, Vector512<T>.Zero); 2241public static Vector512<T> IsPositiveInfinity<T>(Vector512<T> vector) 2245return Equals(vector, Vector512<float>.PositiveInfinity.As<float, T>()); 2249return Equals(vector, Vector512<double>.PositiveInfinity.As<double, T>()); 2251return Vector512<T>.Zero; 2257public static Vector512<T> IsSubnormal<T>(Vector512<T> vector) 2261return LessThan(Abs(vector).AsUInt32() - Vector512<uint>.One, Create<uint>(float.MaxTrailingSignificand)).As<uint, T>(); 2265return LessThan(Abs(vector).AsUInt64() - Vector512<ulong>.One, Create<ulong>(double.MaxTrailingSignificand)).As<ulong, T>(); 2267return Vector512<T>.Zero; 2273public static Vector512<T> IsZero<T>(Vector512<T> vector) => Equals(vector, Vector512<T>.Zero); 2278public static int LastIndexOf<T>(Vector512<T> vector, T value) => 63 - BitOperations.LeadingZeroCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 2283public static int LastIndexOfWhereAllBitsSet<T>(Vector512<T> vector) 2302public static Vector512<double> Lerp(Vector512<double> x, Vector512<double> y, Vector512<double> amount) 2306return VectorMath.Lerp<Vector512<double>, double>(x, y, amount); 2320public static Vector512<float> Lerp(Vector512<float> x, Vector512<float> y, Vector512<float> amount) 2324return VectorMath.Lerp<Vector512<float>, float>(x, y, amount); 2343public static Vector512<T> LessThan<T>(Vector512<T> left, Vector512<T> right) 2359public static bool LessThanAll<T>(Vector512<T> left, Vector512<T> right) 2373public static bool LessThanAny<T>(Vector512<T> left, Vector512<T> right) 2387public static Vector512<T> LessThanOrEqual<T>(Vector512<T> left, Vector512<T> right) 2403public static bool LessThanOrEqualAll<T>(Vector512<T> left, Vector512<T> right) 2417public static bool LessThanOrEqualAny<T>(Vector512<T> left, Vector512<T> right) 2430public static unsafe Vector512<T> Load<T>(T* source) => LoadUnsafe(ref *source); 2440public static unsafe Vector512<T> LoadAligned<T>(T* source) 2449return *(Vector512<T>*)(source); 2460public static unsafe Vector512<T> LoadAlignedNonTemporal<T>(T* source) => LoadAligned(source); 2469public static Vector512<T> LoadUnsafe<T>(ref readonly T source) 2473return Unsafe.ReadUnaligned<Vector512<T>>(in address); 2485public static Vector512<T> LoadUnsafe<T>(ref readonly T source, nuint elementOffset) 2489return Unsafe.ReadUnaligned<Vector512<T>>(in address); 2495internal static Vector512<ushort> LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source)); 2501internal static Vector512<ushort> LoadUnsafe(ref char source, nuint elementOffset) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source), elementOffset); 2505public static Vector512<double> Log(Vector512<double> vector) 2509return VectorMath.LogDouble<Vector512<double>, Vector512<long>, Vector512<ulong>>(vector); 2522public static Vector512<float> Log(Vector512<float> vector) 2526return VectorMath.LogSingle<Vector512<float>, Vector512<int>, Vector512<uint>>(vector); 2539public static Vector512<double> Log2(Vector512<double> vector) 2543return VectorMath.Log2Double<Vector512<double>, Vector512<long>, Vector512<ulong>>(vector); 2556public static Vector512<float> Log2(Vector512<float> vector) 2560return VectorMath.Log2Single<Vector512<float>, Vector512<int>, Vector512<uint>>(vector); 2574public static Vector512<T> Max<T>(Vector512<T> left, Vector512<T> right) 2578return VectorMath.Max<Vector512<T>, T>(left, right); 2592public static Vector512<T> MaxMagnitude<T>(Vector512<T> left, Vector512<T> right) 2596return VectorMath.MaxMagnitude<Vector512<T>, T>(left, right); 2610public static Vector512<T> MaxMagnitudeNumber<T>(Vector512<T> left, Vector512<T> right) 2614return VectorMath.MaxMagnitudeNumber<Vector512<T>, T>(left, right); 2628public static Vector512<T> MaxNative<T>(Vector512<T> left, Vector512<T> right) 2646public static Vector512<T> MaxNumber<T>(Vector512<T> left, Vector512<T> right) 2650return VectorMath.MaxNumber<Vector512<T>, T>(left, right); 2664public static Vector512<T> Min<T>(Vector512<T> left, Vector512<T> right) 2668return VectorMath.Min<Vector512<T>, T>(left, right); 2682public static Vector512<T> MinMagnitude<T>(Vector512<T> left, Vector512<T> right) 2686return VectorMath.MinMagnitude<Vector512<T>, T>(left, right); 2700public static Vector512<T> MinMagnitudeNumber<T>(Vector512<T> left, Vector512<T> right) 2704return VectorMath.MinMagnitudeNumber<Vector512<T>, T>(left, right); 2718public static Vector512<T> MinNative<T>(Vector512<T> left, Vector512<T> right) 2736public static Vector512<T> MinNumber<T>(Vector512<T> left, Vector512<T> right) 2740return VectorMath.MinNumber<Vector512<T>, T>(left, right); 2758public static Vector512<T> Multiply<T>(Vector512<T> left, Vector512<T> right) => left * right; 2767public static Vector512<T> Multiply<T>(Vector512<T> left, T right) => left * right; 2776public static Vector512<T> Multiply<T>(T left, Vector512<T> right) => right * left; 2780internal static Vector512<T> MultiplyAddEstimate<T>(Vector512<T> left, Vector512<T> right, Vector512<T> addend) 2791public static Vector512<double> MultiplyAddEstimate(Vector512<double> left, Vector512<double> right, Vector512<double> addend) 2801public static Vector512<float> MultiplyAddEstimate(Vector512<float> left, Vector512<float> right, Vector512<float> addend) 2811internal static Vector512<TResult> Narrow<TSource, TResult>(Vector512<TSource> lower, Vector512<TSource> upper) 2815Unsafe.SkipInit(out Vector512<TResult> result); 2817for (int i = 0; i < Vector512<TSource>.Count; i++) 2823for (int i = Vector512<TSource>.Count; i < Vector512<TResult>.Count; i++) 2825TResult value = TResult.CreateTruncating(upper.GetElementUnsafe(i - Vector512<TSource>.Count)); 2835public static Vector512<float> Narrow(Vector512<double> lower, Vector512<double> upper) 2842public static Vector512<sbyte> Narrow(Vector512<short> lower, Vector512<short> upper) 2848public static Vector512<short> Narrow(Vector512<int> lower, Vector512<int> upper) 2854public static Vector512<int> Narrow(Vector512<long> lower, Vector512<long> upper) 2861public static Vector512<byte> Narrow(Vector512<ushort> lower, Vector512<ushort> upper) 2868public static Vector512<ushort> Narrow(Vector512<uint> lower, Vector512<uint> upper) 2875public static Vector512<uint> Narrow(Vector512<ulong> lower, Vector512<ulong> upper) 2880internal static Vector512<TResult> NarrowWithSaturation<TSource, TResult>(Vector512<TSource> lower, Vector512<TSource> upper) 2884Unsafe.SkipInit(out Vector512<TResult> result); 2886for (int i = 0; i < Vector512<TSource>.Count; i++) 2892for (int i = Vector512<TSource>.Count; i < Vector512<TResult>.Count; i++) 2894TResult value = TResult.CreateSaturating(upper.GetElementUnsafe(i - Vector512<TSource>.Count)); 2904public static Vector512<float> NarrowWithSaturation(Vector512<double> lower, Vector512<double> upper) 2911public static Vector512<sbyte> NarrowWithSaturation(Vector512<short> lower, Vector512<short> upper) 2917public static Vector512<short> NarrowWithSaturation(Vector512<int> lower, Vector512<int> upper) 2923public static Vector512<int> NarrowWithSaturation(Vector512<long> lower, Vector512<long> upper) 2930public static Vector512<byte> NarrowWithSaturation(Vector512<ushort> lower, Vector512<ushort> upper) 2937public static Vector512<ushort> NarrowWithSaturation(Vector512<uint> lower, Vector512<uint> upper) 2944public static Vector512<uint> NarrowWithSaturation(Vector512<ulong> lower, Vector512<ulong> upper) 2953public static Vector512<T> Negate<T>(Vector512<T> vector) => -vector; 2958public static bool None<T>(Vector512<T> vector, T value) => !EqualsAny(vector, Create(value)); 2963public static bool NoneWhereAllBitsSet<T>(Vector512<T> vector) 2985public static Vector512<T> OnesComplement<T>(Vector512<T> vector) => ~vector; 2990public static Vector512<double> RadiansToDegrees(Vector512<double> radians) 2994return VectorMath.RadiansToDegrees<Vector512<double>, double>(radians); 3008public static Vector512<float> RadiansToDegrees(Vector512<float> radians) 3012return VectorMath.RadiansToDegrees<Vector512<float>, float>(radians); 3025internal static Vector512<T> Round<T>(Vector512<T> vector) 3051public static Vector512<double> Round(Vector512<double> vector) => Round<double>(vector); 3055public static Vector512<float> Round(Vector512<float> vector) => Round<float>(vector); 3059public static Vector512<double> Round(Vector512<double> vector, MidpointRounding mode) => VectorMath.RoundDouble(vector, mode); 3063public static Vector512<float> Round(Vector512<float> vector, MidpointRounding mode) => VectorMath.RoundSingle(vector, mode); 3070internal static Vector512<T> ShiftLeft<T>(Vector512<T> vector, int shiftCount) => vector << shiftCount; 3077public static Vector512<byte> ShiftLeft(Vector512<byte> vector, int shiftCount) => vector << shiftCount; 3084public static Vector512<short> ShiftLeft(Vector512<short> vector, int shiftCount) => vector << shiftCount; 3091public static Vector512<int> ShiftLeft(Vector512<int> vector, int shiftCount) => vector << shiftCount; 3098public static Vector512<long> ShiftLeft(Vector512<long> vector, int shiftCount) => vector << shiftCount; 3105public static Vector512<nint> ShiftLeft(Vector512<nint> vector, int shiftCount) => vector << shiftCount; 3113public static Vector512<nuint> ShiftLeft(Vector512<nuint> vector, int shiftCount) => vector << shiftCount; 3121public static Vector512<sbyte> ShiftLeft(Vector512<sbyte> vector, int shiftCount) => vector << shiftCount; 3129public static Vector512<ushort> ShiftLeft(Vector512<ushort> vector, int shiftCount) => vector << shiftCount; 3137public static Vector512<uint> ShiftLeft(Vector512<uint> vector, int shiftCount) => vector << shiftCount; 3140internal static Vector512<uint> ShiftLeft(Vector512<uint> vector, Vector512<uint> shiftCount) 3154public static Vector512<ulong> ShiftLeft(Vector512<ulong> vector, int shiftCount) => vector << shiftCount; 3157internal static Vector512<ulong> ShiftLeft(Vector512<ulong> vector, Vector512<ulong> shiftCount) 3170internal static Vector512<T> ShiftRightArithmetic<T>(Vector512<T> vector, int shiftCount) => vector >> shiftCount; 3177public static Vector512<short> ShiftRightArithmetic(Vector512<short> vector, int shiftCount) => vector >> shiftCount; 3184public static Vector512<int> ShiftRightArithmetic(Vector512<int> vector, int shiftCount) => vector >> shiftCount; 3191public static Vector512<long> ShiftRightArithmetic(Vector512<long> vector, int shiftCount) => vector >> shiftCount; 3198public static Vector512<nint> ShiftRightArithmetic(Vector512<nint> vector, int shiftCount) => vector >> shiftCount; 3206public static Vector512<sbyte> ShiftRightArithmetic(Vector512<sbyte> vector, int shiftCount) => vector >> shiftCount; 3213internal static Vector512<T> ShiftRightLogical<T>(Vector512<T> vector, int shiftCount) => vector >>> shiftCount; 3220public static Vector512<byte> ShiftRightLogical(Vector512<byte> vector, int shiftCount) => vector >>> shiftCount; 3227public static Vector512<short> ShiftRightLogical(Vector512<short> vector, int shiftCount) => vector >>> shiftCount; 3234public static Vector512<int> ShiftRightLogical(Vector512<int> vector, int shiftCount) => vector >>> shiftCount; 3241public static Vector512<long> ShiftRightLogical(Vector512<long> vector, int shiftCount) => vector >>> shiftCount; 3248public static Vector512<nint> ShiftRightLogical(Vector512<nint> vector, int shiftCount) => vector >>> shiftCount; 3256public static Vector512<nuint> ShiftRightLogical(Vector512<nuint> vector, int shiftCount) => vector >>> shiftCount; 3264public static Vector512<sbyte> ShiftRightLogical(Vector512<sbyte> vector, int shiftCount) => vector >>> shiftCount; 3272public static Vector512<ushort> ShiftRightLogical(Vector512<ushort> vector, int shiftCount) => vector >>> shiftCount; 3280public static Vector512<uint> ShiftRightLogical(Vector512<uint> vector, int shiftCount) => vector >>> shiftCount; 3288public static Vector512<ulong> ShiftRightLogical(Vector512<ulong> vector, int shiftCount) => vector >>> shiftCount; 3296internal static Vector512<byte> ShuffleNativeFallback(Vector512<byte> vector, Vector512<byte> indices) 3302internal static Vector512<sbyte> ShuffleNativeFallback(Vector512<sbyte> vector, Vector512<sbyte> indices) 3308internal static Vector512<short> ShuffleNativeFallback(Vector512<short> vector, Vector512<short> indices) 3314internal static Vector512<ushort> ShuffleNativeFallback(Vector512<ushort> vector, Vector512<ushort> indices) 3320internal static Vector512<int> ShuffleNativeFallback(Vector512<int> vector, Vector512<int> indices) 3326internal static Vector512<uint> ShuffleNativeFallback(Vector512<uint> vector, Vector512<uint> indices) 3332internal static Vector512<float> ShuffleNativeFallback(Vector512<float> vector, Vector512<int> indices) 3338internal static Vector512<long> ShuffleNativeFallback(Vector512<long> vector, Vector512<long> indices) 3344internal static Vector512<ulong> ShuffleNativeFallback(Vector512<ulong> vector, Vector512<ulong> indices) 3350internal static Vector512<double> ShuffleNativeFallback(Vector512<double> vector, Vector512<long> indices) 3361public static Vector512<byte> Shuffle(Vector512<byte> vector, Vector512<byte> indices) 3363Unsafe.SkipInit(out Vector512<byte> result); 3365for (int index = 0; index < Vector512<byte>.Count; index++) 3370if (selectedIndex < Vector512<byte>.Count) 3386public static Vector512<sbyte> Shuffle(Vector512<sbyte> vector, Vector512<sbyte> indices) 3388Unsafe.SkipInit(out Vector512<sbyte> result); 3390for (int index = 0; index < Vector512<sbyte>.Count; index++) 3395if (selectedIndex < Vector512<sbyte>.Count) 3416public static Vector512<byte> ShuffleNative(Vector512<byte> vector, Vector512<byte> indices) 3437public static Vector512<sbyte> ShuffleNative(Vector512<sbyte> vector, Vector512<sbyte> indices) 3451public static Vector512<short> Shuffle(Vector512<short> vector, Vector512<short> indices) 3453Unsafe.SkipInit(out Vector512<short> result); 3455for (int index = 0; index < Vector512<short>.Count; index++) 3460if (selectedIndex < Vector512<short>.Count) 3476public static Vector512<ushort> Shuffle(Vector512<ushort> vector, Vector512<ushort> indices) 3478Unsafe.SkipInit(out Vector512<ushort> result); 3480for (int index = 0; index < Vector512<ushort>.Count; index++) 3485if (selectedIndex < Vector512<ushort>.Count) 3505public static Vector512<short> ShuffleNative(Vector512<short> vector, Vector512<short> indices) 3525public static Vector512<ushort> ShuffleNative(Vector512<ushort> vector, Vector512<ushort> indices) 3539public static Vector512<int> Shuffle(Vector512<int> vector, Vector512<int> indices) 3541Unsafe.SkipInit(out Vector512<int> result); 3543for (int index = 0; index < Vector512<int>.Count; index++) 3548if (selectedIndex < Vector512<int>.Count) 3564public static Vector512<uint> Shuffle(Vector512<uint> vector, Vector512<uint> indices) 3566Unsafe.SkipInit(out Vector512<uint> result); 3568for (int index = 0; index < Vector512<uint>.Count; index++) 3573if (selectedIndex < Vector512<uint>.Count) 3588public static Vector512<float> Shuffle(Vector512<float> vector, Vector512<int> indices) 3590Unsafe.SkipInit(out Vector512<float> result); 3592for (int index = 0; index < Vector512<float>.Count; index++) 3597if (selectedIndex < Vector512<float>.Count) 3617public static Vector512<int> ShuffleNative(Vector512<int> vector, Vector512<int> indices) 3637public static Vector512<uint> ShuffleNative(Vector512<uint> vector, Vector512<uint> indices) 3656public static Vector512<float> ShuffleNative(Vector512<float> vector, Vector512<int> indices) 3670public static Vector512<long> Shuffle(Vector512<long> vector, Vector512<long> indices) 3672Unsafe.SkipInit(out Vector512<long> result); 3674for (int index = 0; index < Vector512<long>.Count; index++) 3679if (selectedIndex < (uint)Vector512<long>.Count) 3695public static Vector512<ulong> Shuffle(Vector512<ulong> vector, Vector512<ulong> indices) 3697Unsafe.SkipInit(out Vector512<ulong> result); 3699for (int index = 0; index < Vector512<ulong>.Count; index++) 3704if (selectedIndex < (uint)Vector512<ulong>.Count) 3719public static Vector512<double> Shuffle(Vector512<double> vector, Vector512<long> indices) 3721Unsafe.SkipInit(out Vector512<double> result); 3723for (int index = 0; index < Vector512<double>.Count; index++) 3728if (selectedIndex < (uint)Vector512<double>.Count) 3748public static Vector512<long> ShuffleNative(Vector512<long> vector, Vector512<long> indices) 3768public static Vector512<ulong> ShuffleNative(Vector512<ulong> vector, Vector512<ulong> indices) 3787public static Vector512<double> ShuffleNative(Vector512<double> vector, Vector512<long> indices) 3798public static Vector512<double> Sin(Vector512<double> vector) 3802return VectorMath.SinDouble<Vector512<double>, Vector512<long>>(vector); 3815public static Vector512<float> Sin(Vector512<float> vector) 3819return VectorMath.SinSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 3832public static (Vector512<double> Sin, Vector512<double> Cos) SinCos(Vector512<double> vector) 3836return VectorMath.SinCosDouble<Vector512<double>, Vector512<long>>(vector); 3852public static (Vector512<float> Sin, Vector512<float> Cos) SinCos(Vector512<float> vector) 3856return VectorMath.SinCosSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 3877public static Vector512<T> Sqrt<T>(Vector512<T> vector) 3892public static unsafe void Store<T>(this Vector512<T> source, T* destination) => source.StoreUnsafe(ref *destination); 3902public static unsafe void StoreAligned<T>(this Vector512<T> source, T* destination) 3911*(Vector512<T>*)(destination) = source; 3922public static unsafe void StoreAlignedNonTemporal<T>(this Vector512<T> source, T* destination) => source.StoreAligned(destination); 3931public static void StoreUnsafe<T>(this Vector512<T> source, ref T destination) 3947public static void StoreUnsafe<T>(this Vector512<T> source, ref T destination, nuint elementOffset) 3956public static Vector512<T> Subtract<T>(Vector512<T> left, Vector512<T> right) => left - right; 3961public static Vector512<T> SubtractSaturate<T>(Vector512<T> left, Vector512<T> right) 3983public static T Sum<T>(Vector512<T> vector) 4000public static T ToScalar<T>(this Vector512<T> vector) 4008internal static Vector512<T> Truncate<T>(Vector512<T> vector) 4034public static Vector512<double> Truncate(Vector512<double> vector) => Truncate<double>(vector); 4038public static Vector512<float> Truncate(Vector512<float> vector) => Truncate<float>(vector); 4044/// <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> 4046public static bool TryCopyTo<T>(this Vector512<T> vector, Span<T> destination) 4048if ((uint)destination.Length < (uint)Vector512<T>.Count) 4057/// <summary>Widens a <see langword="Vector512&lt;Byte&gt;" /> into two <see cref="Vector512{UInt16} " />.</summary> 4062public static (Vector512<ushort> Lower, Vector512<ushort> Upper) Widen(Vector512<byte> source) => (WidenLower(source), WidenUpper(source)); 4064/// <summary>Widens a <see langword="Vector512&lt;Int16&gt;" /> into two <see cref="Vector512{Int32} " />.</summary> 4068public static (Vector512<int> Lower, Vector512<int> Upper) Widen(Vector512<short> source) => (WidenLower(source), WidenUpper(source)); 4070/// <summary>Widens a <see langword="Vector512&lt;Int32&gt;" /> into two <see cref="Vector512{Int64} " />.</summary> 4074public static (Vector512<long> Lower, Vector512<long> Upper) Widen(Vector512<int> source) => (WidenLower(source), WidenUpper(source)); 4076/// <summary>Widens a <see langword="Vector512&lt;SByte&gt;" /> into two <see cref="Vector512{Int16} " />.</summary> 4081public static (Vector512<short> Lower, Vector512<short> Upper) Widen(Vector512<sbyte> source) => (WidenLower(source), WidenUpper(source)); 4083/// <summary>Widens a <see langword="Vector512&lt;Single&gt;" /> into two <see cref="Vector512{Double} " />.</summary> 4087public static (Vector512<double> Lower, Vector512<double> Upper) Widen(Vector512<float> source) => (WidenLower(source), WidenUpper(source)); 4089/// <summary>Widens a <see langword="Vector512&lt;UInt16&gt;" /> into two <see cref="Vector512{UInt32} " />.</summary> 4094public static (Vector512<uint> Lower, Vector512<uint> Upper) Widen(Vector512<ushort> source) => (WidenLower(source), WidenUpper(source)); 4096/// <summary>Widens a <see langword="Vector512&lt;UInt32&gt;" /> into two <see cref="Vector512{UInt64} " />.</summary> 4101public static (Vector512<ulong> Lower, Vector512<ulong> Upper) Widen(Vector512<uint> source) => (WidenLower(source), WidenUpper(source)); 4103/// <summary>Widens the lower half of a <see langword="Vector512&lt;Byte&gt;" /> into a <see cref="Vector512{UInt16} " />.</summary> 4109public static Vector512<ushort> WidenLower(Vector512<byte> source) 4119/// <summary>Widens the lower half of a <see langword="Vector512&lt;Int16&gt;" /> into a <see cref="Vector512{Int32} " />.</summary> 4124public static Vector512<int> WidenLower(Vector512<short> source) 4134/// <summary>Widens the lower half of a <see langword="Vector512&lt;Int32&gt;" /> into a <see cref="Vector512{Int64} " />.</summary> 4139public static Vector512<long> WidenLower(Vector512<int> source) 4149/// <summary>Widens the lower half of a <see langword="Vector512&lt;SByte&gt;" /> into a <see cref="Vector512{Int16} " />.</summary> 4155public static Vector512<short> WidenLower(Vector512<sbyte> source) 4164/// <summary>Widens the lower half of a <see langword="Vector512&lt;Single&gt;" /> into a <see cref="Vector512{Double} " />.</summary> 4169public static Vector512<double> WidenLower(Vector512<float> source) 4179/// <summary>Widens the lower half of a <see langword="Vector512&lt;UInt16&gt;" /> into a <see cref="Vector512{UInt32} " />.</summary> 4185public static Vector512<uint> WidenLower(Vector512<ushort> source) 4195/// <summary>Widens the lower half of a <see langword="Vector512&lt;UInt32&gt;" /> into a <see cref="Vector512{UInt64} " />.</summary> 4201public static Vector512<ulong> WidenLower(Vector512<uint> source) 4211/// <summary>Widens the upper half of a <see langword="Vector512&lt;Byte&gt;" /> into a <see cref="Vector512{UInt16} " />.</summary> 4217public static Vector512<ushort> WidenUpper(Vector512<byte> source) 4227/// <summary>Widens the upper half of a <see langword="Vector512&lt;Int16&gt;" /> into a <see cref="Vector512{Int32} " />.</summary> 4232public static Vector512<int> WidenUpper(Vector512<short> source) 4242/// <summary>Widens the upper half of a <see langword="Vector512&lt;Int32&gt;" /> into a <see cref="Vector512{Int64} " />.</summary> 4247public static Vector512<long> WidenUpper(Vector512<int> source) 4257/// <summary>Widens the upper half of a <see langword="Vector512&lt;SByte&gt;" /> into a <see cref="Vector512{Int16} " />.</summary> 4263public static Vector512<short> WidenUpper(Vector512<sbyte> source) 4273/// <summary>Widens the upper half of a <see langword="Vector512&lt;Single&gt;" /> into a <see cref="Vector512{Double} " />.</summary> 4278public static Vector512<double> WidenUpper(Vector512<float> source) 4288/// <summary>Widens the upper half of a <see langword="Vector512&lt;UInt16&gt;" /> into a <see cref="Vector512{UInt32} " />.</summary> 4294public static Vector512<uint> WidenUpper(Vector512<ushort> source) 4304/// <summary>Widens the upper half of a <see langword="Vector512&lt;UInt32&gt;" /> into a <see cref="Vector512{UInt64} " />.</summary> 4310public static Vector512<ulong> WidenUpper(Vector512<uint> source) 4320/// <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> 4325/// <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> 4329public static Vector512<T> WithElement<T>(this Vector512<T> vector, int index, T value) 4331if ((uint)(index) >= (uint)(Vector512<T>.Count)) 4336Vector512<T> result = vector; 4341/// <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> 4345/// <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> 4349public static Vector512<T> WithLower<T>(this Vector512<T> vector, Vector256<T> value) 4353Vector512<T> result = vector; 4358/// <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> 4362/// <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> 4366public static Vector512<T> WithUpper<T>(this Vector512<T> vector, Vector256<T> value) 4370Vector512<T> result = vector; 4382public static Vector512<T> Xor<T>(Vector512<T> left, Vector512<T> right) => left ^ right; 4385internal static T GetElementUnsafe<T>(in this Vector512<T> vector, int index) 4387Debug.Assert((index >= 0) && (index < Vector512<T>.Count)); 4388ref T address = ref Unsafe.As<Vector512<T>, T>(ref Unsafe.AsRef(in vector)); 4393internal static void SetElementUnsafe<T>(in this Vector512<T> vector, int index, T value) 4395Debug.Assert((index >= 0) && (index < Vector512<T>.Count)); 4396ref T address = ref Unsafe.As<Vector512<T>, T>(ref Unsafe.AsRef(in vector)); 4400internal static void SetLowerUnsafe<T>(in this Vector512<T> vector, Vector256<T> value) => Unsafe.AsRef(in vector._lower) = value; 4402internal 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) 343return vector ^ Vector512<float>.NegativeZero.As<float, T>(); 347return vector ^ Vector512<double>.NegativeZero.As<double, T>(); 360public static Vector512<T> operator +(Vector512<T> value) 372public static Vector512<T> operator >>>(Vector512<T> value, int shiftCount) 382/// <returns><c>true</c> if <paramref name="obj" /> is a <see cref="Vector512{T}" /> and is equal to the current instance; otherwise, <c>false</c>.</returns> 383public override bool Equals([NotNullWhen(true)] object? obj) => (obj is Vector512<T> other) && Equals(other); 385/// <summary>Determines whether the specified <see cref="Vector512{T}" /> is equal to the current instance.</summary> 386/// <param name="other">The <see cref="Vector512{T}" /> to compare with the current instance.</param> 390public bool Equals(Vector512<T> other) 399Vector512<T> result = Vector512.Equals(this, other) | ~(Vector512.Equals(this, this) | Vector512.Equals(other, other)); 400return result.AsInt32() == Vector512<int>.AllBitsSet; 461static int ISimdVector<Vector512<T>, T>.Alignment => Vector512.Alignment; 464static int ISimdVector<Vector512<T>, T>.ElementCount => Vector512<T>.Count; 467static bool ISimdVector<Vector512<T>, T>.IsHardwareAccelerated 475static Vector512<T> ISimdVector<Vector512<T>, T>.Abs(Vector512<T> vector) => Vector512.Abs(vector); 479static Vector512<T> ISimdVector<Vector512<T>, T>.Add(Vector512<T> left, Vector512<T> right) => left + right; 483static bool ISimdVector<Vector512<T>, T>.All(Vector512<T> vector, T value) => Vector512.All(vector, value); 487static bool ISimdVector<Vector512<T>, T>.AllWhereAllBitsSet(Vector512<T> vector) => Vector512.AllWhereAllBitsSet(vector); 491static Vector512<T> ISimdVector<Vector512<T>, T>.AndNot(Vector512<T> left, Vector512<T> right) => Vector512.AndNot(left, right); 495static bool ISimdVector<Vector512<T>, T>.Any(Vector512<T> vector, T value) => Vector512.Any(vector, value); 499static bool ISimdVector<Vector512<T>, T>.AnyWhereAllBitsSet(Vector512<T> vector) => Vector512.AnyWhereAllBitsSet(vector); 503static Vector512<T> ISimdVector<Vector512<T>, T>.BitwiseAnd(Vector512<T> left, Vector512<T> right) => left & right; 507static Vector512<T> ISimdVector<Vector512<T>, T>.BitwiseOr(Vector512<T> left, Vector512<T> right) => left | right; 511static Vector512<T> ISimdVector<Vector512<T>, T>.Ceiling(Vector512<T> vector) => Vector512.Ceiling(vector); 515static Vector512<T> ISimdVector<Vector512<T>, T>.Clamp(Vector512<T> value, Vector512<T> min, Vector512<T> max) => Vector512.Clamp(value, min, max); 519static Vector512<T> ISimdVector<Vector512<T>, T>.ClampNative(Vector512<T> value, Vector512<T> min, Vector512<T> max) => Vector512.ClampNative(value, min, max); 523static Vector512<T> ISimdVector<Vector512<T>, T>.ConditionalSelect(Vector512<T> condition, Vector512<T> left, Vector512<T> right) => Vector512.ConditionalSelect(condition, left, right); 527static Vector512<T> ISimdVector<Vector512<T>, T>.CopySign(Vector512<T> value, Vector512<T> sign) => Vector512.CopySign(value, sign); 530static void ISimdVector<Vector512<T>, T>.CopyTo(Vector512<T> vector, T[] destination) => vector.CopyTo(destination); 533static void ISimdVector<Vector512<T>, T>.CopyTo(Vector512<T> vector, T[] destination, int startIndex) => vector.CopyTo(destination, startIndex); 536static void ISimdVector<Vector512<T>, T>.CopyTo(Vector512<T> vector, Span<T> destination) => vector.CopyTo(destination); 540static int ISimdVector<Vector512<T>, T>.Count(Vector512<T> vector, T value) => Vector512.Count(vector, value); 544static int ISimdVector<Vector512<T>, T>.CountWhereAllBitsSet(Vector512<T> vector) => Vector512.CountWhereAllBitsSet(vector); 548static Vector512<T> ISimdVector<Vector512<T>, T>.Create(T value) => Vector512.Create(value); 551static Vector512<T> ISimdVector<Vector512<T>, T>.Create(T[] values) => Vector512.Create(values); 554static Vector512<T> ISimdVector<Vector512<T>, T>.Create(T[] values, int index) => Vector512.Create(values, index); 557static Vector512<T> ISimdVector<Vector512<T>, T>.Create(ReadOnlySpan<T> values) => Vector512.Create(values); 561static Vector512<T> ISimdVector<Vector512<T>, T>.CreateScalar(T value) => Vector512.CreateScalar(value); 565static Vector512<T> ISimdVector<Vector512<T>, T>.CreateScalarUnsafe(T value) => Vector512.CreateScalarUnsafe(value); 569static Vector512<T> ISimdVector<Vector512<T>, T>.Divide(Vector512<T> left, Vector512<T> right) => left / right; 573static Vector512<T> ISimdVector<Vector512<T>, T>.Divide(Vector512<T> left, T right) => left / right; 577static T ISimdVector<Vector512<T>, T>.Dot(Vector512<T> left, Vector512<T> right) => Vector512.Dot(left, right); 581static Vector512<T> ISimdVector<Vector512<T>, T>.Equals(Vector512<T> left, Vector512<T> right) => Vector512.Equals(left, right); 585static bool ISimdVector<Vector512<T>, T>.EqualsAll(Vector512<T> left, Vector512<T> right) => left == right; 589static bool ISimdVector<Vector512<T>, T>.EqualsAny(Vector512<T> left, Vector512<T> right) => Vector512.EqualsAny(left, right); 593static Vector512<T> ISimdVector<Vector512<T>, T>.Floor(Vector512<T> vector) => Vector512.Floor(vector); 597static T ISimdVector<Vector512<T>, T>.GetElement(Vector512<T> vector, int index) => vector.GetElement(index); 601static Vector512<T> ISimdVector<Vector512<T>, T>.GreaterThan(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThan(left, right); 605static bool ISimdVector<Vector512<T>, T>.GreaterThanAll(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanAll(left, right); 609static bool ISimdVector<Vector512<T>, T>.GreaterThanAny(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanAny(left, right); 613static Vector512<T> ISimdVector<Vector512<T>, T>.GreaterThanOrEqual(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanOrEqual(left, right); 617static bool ISimdVector<Vector512<T>, T>.GreaterThanOrEqualAll(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanOrEqualAll(left, right); 621static bool ISimdVector<Vector512<T>, T>.GreaterThanOrEqualAny(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanOrEqualAny(left, right); 625static int ISimdVector<Vector512<T>, T>.IndexOf(Vector512<T> vector, T value) => Vector512.IndexOf(vector, value); 629static int ISimdVector<Vector512<T>, T>.IndexOfWhereAllBitsSet(Vector512<T> vector) => Vector512.IndexOfWhereAllBitsSet(vector); 633static Vector512<T> ISimdVector<Vector512<T>, T>.IsEvenInteger(Vector512<T> vector) => Vector512.IsEvenInteger(vector); 637static Vector512<T> ISimdVector<Vector512<T>, T>.IsFinite(Vector512<T> vector) => Vector512.IsFinite(vector); 641static Vector512<T> ISimdVector<Vector512<T>, T>.IsInfinity(Vector512<T> vector) => Vector512.IsInfinity(vector); 645static Vector512<T> ISimdVector<Vector512<T>, T>.IsInteger(Vector512<T> vector) => Vector512.IsInteger(vector); 649static Vector512<T> ISimdVector<Vector512<T>, T>.IsNaN(Vector512<T> vector) => Vector512.IsNaN(vector); 653static Vector512<T> ISimdVector<Vector512<T>, T>.IsNegative(Vector512<T> vector) => Vector512.IsNegative(vector); 657static Vector512<T> ISimdVector<Vector512<T>, T>.IsNegativeInfinity(Vector512<T> vector) => Vector512.IsNegativeInfinity(vector); 661static Vector512<T> ISimdVector<Vector512<T>, T>.IsNormal(Vector512<T> vector) => Vector512.IsNormal(vector); 665static Vector512<T> ISimdVector<Vector512<T>, T>.IsOddInteger(Vector512<T> vector) => Vector512.IsOddInteger(vector); 669static Vector512<T> ISimdVector<Vector512<T>, T>.IsPositive(Vector512<T> vector) => Vector512.IsPositive(vector); 673static Vector512<T> ISimdVector<Vector512<T>, T>.IsPositiveInfinity(Vector512<T> vector) => Vector512.IsPositiveInfinity(vector); 677static Vector512<T> ISimdVector<Vector512<T>, T>.IsSubnormal(Vector512<T> vector) => Vector512.IsSubnormal(vector); 680static Vector512<T> ISimdVector<Vector512<T>, T>.IsZero(Vector512<T> vector) => Vector512.IsZero(vector); 684static int ISimdVector<Vector512<T>, T>.LastIndexOf(Vector512<T> vector, T value) => Vector512.LastIndexOf(vector, value); 688static int ISimdVector<Vector512<T>, T>.LastIndexOfWhereAllBitsSet(Vector512<T> vector) => Vector512.LastIndexOfWhereAllBitsSet(vector); 692static Vector512<T> ISimdVector<Vector512<T>, T>.LessThan(Vector512<T> left, Vector512<T> right) => Vector512.LessThan(left, right); 696static bool ISimdVector<Vector512<T>, T>.LessThanAll(Vector512<T> left, Vector512<T> right) => Vector512.LessThanAll(left, right); 700static bool ISimdVector<Vector512<T>, T>.LessThanAny(Vector512<T> left, Vector512<T> right) => Vector512.LessThanAny(left, right); 704static Vector512<T> ISimdVector<Vector512<T>, T>.LessThanOrEqual(Vector512<T> left, Vector512<T> right) => Vector512.LessThanOrEqual(left, right); 708static bool ISimdVector<Vector512<T>, T>.LessThanOrEqualAll(Vector512<T> left, Vector512<T> right) => Vector512.LessThanOrEqualAll(left, right); 712static bool ISimdVector<Vector512<T>, T>.LessThanOrEqualAny(Vector512<T> left, Vector512<T> right) => Vector512.LessThanOrEqualAny(left, right); 716static Vector512<T> ISimdVector<Vector512<T>, T>.Load(T* source) => Vector512.Load(source); 720static Vector512<T> ISimdVector<Vector512<T>, T>.LoadAligned(T* source) => Vector512.LoadAligned(source); 724static Vector512<T> ISimdVector<Vector512<T>, T>.LoadAlignedNonTemporal(T* source) => Vector512.LoadAlignedNonTemporal(source); 728static Vector512<T> ISimdVector<Vector512<T>, T>.LoadUnsafe(ref readonly T source) => Vector512.LoadUnsafe(in source); 732static Vector512<T> ISimdVector<Vector512<T>, T>.LoadUnsafe(ref readonly T source, nuint elementOffset) => Vector512.LoadUnsafe(in source, elementOffset); 736static Vector512<T> ISimdVector<Vector512<T>, T>.Max(Vector512<T> left, Vector512<T> right) => Vector512.Max(left, right); 740static Vector512<T> ISimdVector<Vector512<T>, T>.MaxMagnitude(Vector512<T> left, Vector512<T> right) => Vector512.MaxMagnitude(left, right); 744static Vector512<T> ISimdVector<Vector512<T>, T>.MaxMagnitudeNumber(Vector512<T> left, Vector512<T> right) => Vector512.MaxMagnitudeNumber(left, right); 748static Vector512<T> ISimdVector<Vector512<T>, T>.MaxNative(Vector512<T> left, Vector512<T> right) => Vector512.MaxNative(left, right); 752static Vector512<T> ISimdVector<Vector512<T>, T>.MaxNumber(Vector512<T> left, Vector512<T> right) => Vector512.MaxNumber(left, right); 756static Vector512<T> ISimdVector<Vector512<T>, T>.Min(Vector512<T> left, Vector512<T> right) => Vector512.Min(left, right); 760static Vector512<T> ISimdVector<Vector512<T>, T>.MinMagnitude(Vector512<T> left, Vector512<T> right) => Vector512.MinMagnitude(left, right); 764static Vector512<T> ISimdVector<Vector512<T>, T>.MinMagnitudeNumber(Vector512<T> left, Vector512<T> right) => Vector512.MinMagnitudeNumber(left, right); 768static Vector512<T> ISimdVector<Vector512<T>, T>.MinNative(Vector512<T> left, Vector512<T> right) => Vector512.MinNative(left, right); 772static Vector512<T> ISimdVector<Vector512<T>, T>.MinNumber(Vector512<T> left, Vector512<T> right) => Vector512.MinNumber(left, right); 776static Vector512<T> ISimdVector<Vector512<T>, T>.Multiply(Vector512<T> left, Vector512<T> right) => left * right; 780static Vector512<T> ISimdVector<Vector512<T>, T>.Multiply(Vector512<T> left, T right) => left * right; 784static Vector512<T> ISimdVector<Vector512<T>, T>.MultiplyAddEstimate(Vector512<T> left, Vector512<T> right, Vector512<T> addend) => Vector512.MultiplyAddEstimate(left, right, addend); 788static Vector512<T> ISimdVector<Vector512<T>, T>.Negate(Vector512<T> vector) => -vector; 792static bool ISimdVector<Vector512<T>, T>.None(Vector512<T> vector, T value) => Vector512.None(vector, value); 796static bool ISimdVector<Vector512<T>, T>.NoneWhereAllBitsSet(Vector512<T> vector) => Vector512.NoneWhereAllBitsSet(vector); 800static Vector512<T> ISimdVector<Vector512<T>, T>.OnesComplement(Vector512<T> vector) => ~vector; 804static Vector512<T> ISimdVector<Vector512<T>, T>.Round(Vector512<T> vector) => Vector512.Round(vector); 808static Vector512<T> ISimdVector<Vector512<T>, T>.ShiftLeft(Vector512<T> vector, int shiftCount) => vector << shiftCount; 812static Vector512<T> ISimdVector<Vector512<T>, T>.ShiftRightArithmetic(Vector512<T> vector, int shiftCount) => vector >> shiftCount; 816static Vector512<T> ISimdVector<Vector512<T>, T>.ShiftRightLogical(Vector512<T> vector, int shiftCount) => vector >>> shiftCount; 820static Vector512<T> ISimdVector<Vector512<T>, T>.Sqrt(Vector512<T> vector) => Vector512.Sqrt(vector); 824static void ISimdVector<Vector512<T>, T>.Store(Vector512<T> source, T* destination) => source.Store(destination); 828static void ISimdVector<Vector512<T>, T>.StoreAligned(Vector512<T> source, T* destination) => source.StoreAligned(destination); 832static void ISimdVector<Vector512<T>, T>.StoreAlignedNonTemporal(Vector512<T> source, T* destination) => source.StoreAlignedNonTemporal(destination); 836static void ISimdVector<Vector512<T>, T>.StoreUnsafe(Vector512<T> vector, ref T destination) => vector.StoreUnsafe(ref destination); 840static void ISimdVector<Vector512<T>, T>.StoreUnsafe(Vector512<T> vector, ref T destination, nuint elementOffset) => vector.StoreUnsafe(ref destination, elementOffset); 844static Vector512<T> ISimdVector<Vector512<T>, T>.Subtract(Vector512<T> left, Vector512<T> right) => left - right; 848static T ISimdVector<Vector512<T>, T>.Sum(Vector512<T> vector) => Vector512.Sum(vector); 852static T ISimdVector<Vector512<T>, T>.ToScalar(Vector512<T> vector) => vector.ToScalar(); 856static Vector512<T> ISimdVector<Vector512<T>, T>.Truncate(Vector512<T> vector) => Vector512.Truncate(vector); 859static bool ISimdVector<Vector512<T>, T>.TryCopyTo(Vector512<T> vector, Span<T> destination) => vector.TryCopyTo(destination); 863static Vector512<T> ISimdVector<Vector512<T>, T>.WithElement(Vector512<T> vector, int index, T value) => vector.WithElement(index, value); 867static Vector512<T> ISimdVector<Vector512<T>, T>.Xor(Vector512<T> left, Vector512<T> right) => left ^ right;

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

2377else if (typeof(TVectorInt64) == typeof(Vector512<long>)) 2379result = (TVectorDouble)(object)Vector512.ConvertToDouble((Vector512<long>)(object)vector); 2412else if (typeof(TVectorInt32) == typeof(Vector512<int>)) 2414result = (TVectorSingle)(object)Vector512.ConvertToSingle((Vector512<int>)(object)vector); 2536else if (typeof(TVector) == typeof(Vector512<double>)) 2570else if (typeof(TVector) == typeof(Vector512<float>)) 2621else if (typeof(TVectorDouble) == typeof(Vector512<double>)) 2627result = (TVectorSingle)(object)Avx512F.ConvertToVector256Single((Vector512<double>)(object)vector); 2631Vector512<double> value = (Vector512<double>)(object)vector; 2670else if (typeof(TVectorDouble) == typeof(Vector512<double>)) 2672Debug.Assert(typeof(TVectorSingle) == typeof(Vector512<float>)); 2673result = (TVectorSingle)(object)Vector512.Narrow((Vector512<double>)(object)lower, (Vector512<double>)(object)upper); 2717else if (typeof(TVectorUInt32) == typeof(Vector512<uint>)) 2720(Vector512<uint>)(object)vector, 2721(Vector512<uint>)(object)shiftAmount 2766else if (typeof(TVectorUInt64) == typeof(Vector512<ulong>)) 2769(Vector512<ulong>)(object)vector, 2770(Vector512<ulong>)(object)shiftAmount 2949Debug.Assert(typeof(TVectorDouble) == typeof(Vector512<double>)); 3000else if (typeof(TVectorSingle) == typeof(Vector512<float>)) 3002Debug.Assert(typeof(TVectorDouble) == typeof(Vector512<double>)); 3003result = (TVectorDouble)(object)Vector512.WidenLower((Vector512<float>)(object)vector); 3040else if (typeof(TVectorSingle) == typeof(Vector512<float>)) 3042Debug.Assert(typeof(TVectorDouble) == typeof(Vector512<double>)); 3043result = (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);