139for (; i <= (uint)values.Length - Vector512<byte>.Count; i += (uint)Vector512<byte>.Count) 141Vector512<byte> vector = Vector512.LoadUnsafe(ref value, i); 142Vector512<byte> isFalse = Vector512.Equals(vector, Vector512<byte>.Zero); 349if (Vector512.IsHardwareAccelerated && (uint)count >= Vector512<int>.Count) 351for (; i < (uint)count - (Vector512<int>.Count - 1u); i += (uint)Vector512<int>.Count) 353Vector512<int> result = Vector512.LoadUnsafe(ref left, i) & Vector512.LoadUnsafe(ref right, i); 422if (Vector512.IsHardwareAccelerated && (uint)count >= Vector512<int>.Count) 424for (; i < (uint)count - (Vector512<int>.Count - 1u); i += (uint)Vector512<int>.Count) 426Vector512<int> result = Vector512.LoadUnsafe(ref left, i) | Vector512.LoadUnsafe(ref right, i); 496if (Vector512.IsHardwareAccelerated && (uint)count >= Vector512<int>.Count) 498for (; i < (uint)count - (Vector512<int>.Count - 1u); i += (uint)Vector512<int>.Count) 500Vector512<int> result = Vector512.LoadUnsafe(ref left, i) ^ Vector512.LoadUnsafe(ref right, i); 561if (Vector512.IsHardwareAccelerated && (uint)count >= Vector512<int>.Count) 563for (; i < (uint)count - (Vector512<int>.Count - 1u); i += (uint)Vector512<int>.Count) 565Vector512<int> result = ~Vector512.LoadUnsafe(ref value, i); 840if (Avx512F.IsSupported && (uint)m_length >= Vector512<byte>.Count) 845Vector512<byte> shuffleMask = Vector512.Create(lowerShuffleMask_CopyToBoolArray256, upperShuffleMask_CopyToBoolArray256); 846Vector512<byte> bitMask = Vector512.Create(0x80402010_08040201).AsByte(); 847Vector512<byte> ones = Vector512.Create((byte)1); 851for (; (i + Vector512<byte>.Count) <= (uint)m_length; i += (uint)Vector512<byte>.Count) 854Vector512<ulong> scalar = Vector512.Create(bits); 855Vector512<byte> shuffled = Avx512BW.Shuffle(scalar.AsByte(), shuffleMask); 856Vector512<byte> extracted = Avx512F.And(shuffled, bitMask); 860Vector512<byte> normalized = Avx512BW.Min(extracted, ones);

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

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

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

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

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

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

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

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

19static abstract Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z); 28public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z) => TOperator.Invoke(x, z, y); 70if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported) 72if (remainder >= (uint)Vector512<T>.Count) 692Vector512<T> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef), 695Vector512<T> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count), 696Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count), 697Vector512.LoadUnsafe(ref zRef, remainder - (uint)Vector512<T>.Count)); 699if (remainder > (uint)(Vector512<T>.Count * 8)) 728nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T); 735Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0); 740Vector512<T> vector1; 741Vector512<T> vector2; 742Vector512<T> vector3; 743Vector512<T> vector4; 750while (remainder >= (uint)(Vector512<T>.Count * 8)) 754vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 755Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)), 756Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 0))); 757vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 758Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)), 759Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 1))); 760vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 761Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)), 762Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 2))); 763vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 764Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)), 765Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 3))); 767vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 0)); 768vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 1)); 769vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 2)); 770vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 3)); 774vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 775Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)), 776Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 4))); 777vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 778Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)), 779Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 5))); 780vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 781Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)), 782Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 6))); 783vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 784Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)), 785Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 7))); 787vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 4)); 788vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 5)); 789vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 6)); 790vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 7)); 795xPtr += (uint)(Vector512<T>.Count * 8); 796yPtr += (uint)(Vector512<T>.Count * 8); 797zPtr += (uint)(Vector512<T>.Count * 8); 798dPtr += (uint)(Vector512<T>.Count * 8); 800remainder -= (uint)(Vector512<T>.Count * 8); 805while (remainder >= (uint)(Vector512<T>.Count * 8)) 809vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 810Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)), 811Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 0))); 812vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 813Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)), 814Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 1))); 815vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 816Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)), 817Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 2))); 818vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 819Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)), 820Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 3))); 822vector1.Store(dPtr + (uint)(Vector512<T>.Count * 0)); 823vector2.Store(dPtr + (uint)(Vector512<T>.Count * 1)); 824vector3.Store(dPtr + (uint)(Vector512<T>.Count * 2)); 825vector4.Store(dPtr + (uint)(Vector512<T>.Count * 3)); 829vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 830Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)), 831Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 4))); 832vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 833Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)), 834Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 5))); 835vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 836Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)), 837Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 6))); 838vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 839Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)), 840Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 7))); 842vector1.Store(dPtr + (uint)(Vector512<T>.Count * 4)); 843vector2.Store(dPtr + (uint)(Vector512<T>.Count * 5)); 844vector3.Store(dPtr + (uint)(Vector512<T>.Count * 6)); 845vector4.Store(dPtr + (uint)(Vector512<T>.Count * 7)); 850xPtr += (uint)(Vector512<T>.Count * 8); 851yPtr += (uint)(Vector512<T>.Count * 8); 852zPtr += (uint)(Vector512<T>.Count * 8); 853dPtr += (uint)(Vector512<T>.Count * 8); 855remainder -= (uint)(Vector512<T>.Count * 8); 876remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count); 878switch (remainder / (uint)Vector512<T>.Count) 882Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)), 883Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 8)), 884Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 8))); 885vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8)); 891Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)), 892Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 7)), 893Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 7))); 894vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7)); 900Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)), 901Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 6)), 902Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 6))); 903vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6)); 909Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)), 910Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 5)), 911Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 5))); 912vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5)); 918Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)), 919Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 4)), 920Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 4))); 921vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4)); 927Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)), 928Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 3)), 929Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 3))); 930vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3)); 936Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)), 937Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 2)), 938Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 2))); 939vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 2)); 946end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count); 1545if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported) 1547if (remainder >= (uint)Vector512<T>.Count) 2159Vector512<T> zVec = Vector512.Create(z); 2161Vector512<T> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef), 2164Vector512<T> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count), 2165Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count), 2168if (remainder > (uint)(Vector512<T>.Count * 8)) 2195nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T); 2201Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0); 2206Vector512<T> vector1; 2207Vector512<T> vector2; 2208Vector512<T> vector3; 2209Vector512<T> vector4; 2216while (remainder >= (uint)(Vector512<T>.Count * 8)) 2220vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 2221Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)), 2223vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 2224Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)), 2226vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 2227Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)), 2229vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 2230Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)), 2233vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 0)); 2234vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 1)); 2235vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 2)); 2236vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 3)); 2240vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 2241Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)), 2243vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 2244Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)), 2246vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 2247Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)), 2249vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 2250Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)), 2253vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 4)); 2254vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 5)); 2255vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 6)); 2256vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 7)); 2261xPtr += (uint)(Vector512<T>.Count * 8); 2262yPtr += (uint)(Vector512<T>.Count * 8); 2263dPtr += (uint)(Vector512<T>.Count * 8); 2265remainder -= (uint)(Vector512<T>.Count * 8); 2270while (remainder >= (uint)(Vector512<T>.Count * 8)) 2274vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 2275Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)), 2277vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 2278Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)), 2280vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 2281Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)), 2283vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 2284Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)), 2287vector1.Store(dPtr + (uint)(Vector512<T>.Count * 0)); 2288vector2.Store(dPtr + (uint)(Vector512<T>.Count * 1)); 2289vector3.Store(dPtr + (uint)(Vector512<T>.Count * 2)); 2290vector4.Store(dPtr + (uint)(Vector512<T>.Count * 3)); 2294vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 2295Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)), 2297vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 2298Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)), 2300vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 2301Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)), 2303vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 2304Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)), 2307vector1.Store(dPtr + (uint)(Vector512<T>.Count * 4)); 2308vector2.Store(dPtr + (uint)(Vector512<T>.Count * 5)); 2309vector3.Store(dPtr + (uint)(Vector512<T>.Count * 6)); 2310vector4.Store(dPtr + (uint)(Vector512<T>.Count * 7)); 2315xPtr += (uint)(Vector512<T>.Count * 8); 2316yPtr += (uint)(Vector512<T>.Count * 8); 2317dPtr += (uint)(Vector512<T>.Count * 8); 2319remainder -= (uint)(Vector512<T>.Count * 8); 2339remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count); 2341switch (remainder / (uint)Vector512<T>.Count) 2345Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)), 2346Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 8)), 2348vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8)); 2354Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)), 2355Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 7)), 2357vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7)); 2363Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)), 2364Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 6)), 2366vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6)); 2372Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)), 2373Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 5)), 2375vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5)); 2381Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)), 2382Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 4)), 2384vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4)); 2390Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)), 2391Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 3)), 2393vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3)); 2399Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)), 2400Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 2)), 2402vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 2)); 2409end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count); 3031if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported) 3033if (remainder >= (uint)Vector512<T>.Count) 3635Vector512<T> yVec = Vector512.Create(y); 3636Vector512<T> zVec = Vector512.Create(z); 3638Vector512<T> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef), 3641Vector512<T> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count), 3645if (remainder > (uint)(Vector512<T>.Count * 8)) 3670nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T); 3675Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0); 3680Vector512<T> vector1; 3681Vector512<T> vector2; 3682Vector512<T> vector3; 3683Vector512<T> vector4; 3690while (remainder >= (uint)(Vector512<T>.Count * 8)) 3694vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 3697vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 3700vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 3703vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 3707vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 0)); 3708vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 1)); 3709vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 2)); 3710vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 3)); 3714vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 3717vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 3720vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 3723vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 3727vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 4)); 3728vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 5)); 3729vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 6)); 3730vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 7)); 3735xPtr += (uint)(Vector512<T>.Count * 8); 3736dPtr += (uint)(Vector512<T>.Count * 8); 3738remainder -= (uint)(Vector512<T>.Count * 8); 3743while (remainder >= (uint)(Vector512<T>.Count * 8)) 3747vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)), 3750vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)), 3753vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)), 3756vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)), 3760vector1.Store(dPtr + (uint)(Vector512<T>.Count * 0)); 3761vector2.Store(dPtr + (uint)(Vector512<T>.Count * 1)); 3762vector3.Store(dPtr + (uint)(Vector512<T>.Count * 2)); 3763vector4.Store(dPtr + (uint)(Vector512<T>.Count * 3)); 3767vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)), 3770vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)), 3773vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)), 3776vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)), 3780vector1.Store(dPtr + (uint)(Vector512<T>.Count * 4)); 3781vector2.Store(dPtr + (uint)(Vector512<T>.Count * 5)); 3782vector3.Store(dPtr + (uint)(Vector512<T>.Count * 6)); 3783vector4.Store(dPtr + (uint)(Vector512<T>.Count * 7)); 3788xPtr += (uint)(Vector512<T>.Count * 8); 3789dPtr += (uint)(Vector512<T>.Count * 8); 3791remainder -= (uint)(Vector512<T>.Count * 8); 3810remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count); 3812switch (remainder / (uint)Vector512<T>.Count) 3816Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)), 3819vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8)); 3825Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)), 3828vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7)); 3834Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)), 3837vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6)); 3843Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)), 3846vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5)); 3852Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)), 3855vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4)); 3861Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)), 3864vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3)); 3870Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)), 3873vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 2)); 3880end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count);

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

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

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

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

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

85public static Vector512<T> Invoke(Vector512<T> x) 96Vector512<T> abs = Vector512.ConditionalSelect(Vector512.LessThan(x, Vector512<T>.Zero), -x, x); 97if (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);

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

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

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

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

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

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

180public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> min, Vector512<T> max) => Vector512.Clamp(x, min, max); 228public static Vector512<T> Invoke(Vector512<T> min, Vector512<T> max, Vector512<T> x) => Vector512.Clamp(x, min, max); 277public static Vector512<T> Invoke(Vector512<T> max, Vector512<T> x, Vector512<T> min) => Vector512.Clamp(x, min, max);

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

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

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

74public static Vector512<TTo> Invoke(Vector512<TFrom> x)

74public static Vector512<TTo> Invoke(Vector512<TFrom> x)

111public static Vector512<int> Invoke(Vector512<float> x) => Vector512.ConvertToInt32(x); 122public static Vector512<uint> Invoke(Vector512<float> x) => Vector512.ConvertToUInt32(x); 133public static Vector512<ulong> Invoke(Vector512<double> x) => Vector512.ConvertToUInt64(x); 144public static Vector512<long> Invoke(Vector512<double> x) => Vector512.ConvertToInt64(x); 155public static Vector512<byte> Invoke(Vector512<ushort> lower, Vector512<ushort> upper) => Vector512.Narrow(lower, upper); 166public static Vector512<sbyte> Invoke(Vector512<short> lower, Vector512<short> upper) => Vector512.Narrow(lower, upper); 177public static Vector512<ushort> Invoke(Vector512<uint> lower, Vector512<uint> upper) => Vector512.Narrow(lower, upper); 188public static Vector512<short> Invoke(Vector512<int> lower, Vector512<int> upper) => Vector512.Narrow(lower, upper); 199public static Vector512<uint> Invoke(Vector512<ulong> lower, Vector512<ulong> upper) => Vector512.Narrow(lower, upper); 210public static Vector512<int> Invoke(Vector512<long> lower, Vector512<long> upper) => Vector512.Narrow(lower, upper); 221public static Vector512<TTo> Invoke(Vector512<TFrom> x) => throw new NotSupportedException();

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

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

115public static Vector512<T> Invoke(Vector512<T> t) 119Vector512<float> x = t.AsSingle(); 121Vector512<float> y = Vector512.Abs(x); 122Vector512<float> z = ExpOperator<float>.Invoke(y - Vector512.Create((float)Single_LOGV)); 128Vector512<double> x = t.AsDouble(); 130Vector512<double> y = Vector512.Abs(x); 131Vector512<double> z = ExpOperator<double>.Invoke(y - Vector512.Create(Double_LOGV));

52if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 57Vector512<T> dotProductVector = Vector512<T>.Zero; 58Vector512<T> xSumOfSquaresVector = Vector512<T>.Zero; 59Vector512<T> ySumOfSquaresVector = Vector512<T>.Zero; 62int oneVectorFromEnd = x.Length - Vector512<T>.Count; 66Vector512<T> xVec = Vector512.LoadUnsafe(ref xRef, (uint)i); 67Vector512<T> yVec = Vector512.LoadUnsafe(ref yRef, (uint)i); 73i += Vector512<T>.Count; 80Vector512<T> xVec = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 81Vector512<T> yVec = Vector512.LoadUnsafe(ref yRef, (uint)(x.Length - Vector512<T>.Count)); 83Vector512<T> remainderMask = CreateRemainderMaskVector512<T>(x.Length - i);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

124public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) 142public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x); 177private static Vector512<T> IsNaN<T>(Vector512<T> vector) 252private static Vector512<T> IsNegative<T>(Vector512<T> vector) 342private static Vector512<T> IsPositive<T>(Vector512<T> vector) 388if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 394Vector512<T> result = Vector512.LoadUnsafe(ref xRef, 0); 395Vector512<T> current; 397Vector512<T> nanMask; 402if (nanMask != Vector512<T>.Zero) 408int oneVectorFromEnd = x.Length - Vector512<T>.Count; 409int i = Vector512<T>.Count; 421if (nanMask != Vector512<T>.Zero) 428i += Vector512<T>.Count; 434current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 440if (nanMask != Vector512<T>.Zero)

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

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

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

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

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

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

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

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

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

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

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

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

78public static Vector512<T> Invoke(Vector512<T> x) => Vector512<T>.One / x; 87public static Vector512<T> Invoke(Vector512<T> x) => Vector512<T>.One / Vector512.Sqrt(x); 142public static Vector512<T> Invoke(Vector512<T> x) 152return Vector512<T>.One / x; 208public static Vector512<T> Invoke(Vector512<T> x) 218return Vector512<T>.One / Vector512.Sqrt(x);

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

217public static Vector512<T> Invoke(Vector512<T> x) 280public static Vector512<T> Invoke(Vector512<T> x) 336public Vector512<T> Invoke(Vector512<T> x) 338Vector512<T> limit = Vector512.Create(typeof(T) == typeof(float) ? T.CreateTruncating(Single_RoundLimit) : T.CreateTruncating(Double_RoundLimit)); 358public Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();

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

65public Vector512<T> Invoke(Vector512<T> x) => x << _amount; 78public Vector512<T> Invoke(Vector512<T> x) => x >> _amount; 91public Vector512<T> Invoke(Vector512<T> x) => x >>> _amount;

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

91public static Vector512<int> Invoke(Vector512<T> x) 95return Vector512.ConditionalSelect(Vector512.Equals(x, Vector512<T>.Zero).AsInt32(), 96Vector512<int>.Zero, 97Vector512<int>.One); 101Vector512<int> value = x.AsInt32(); 106if (Vector512.EqualsAny(IsNaN(x).AsInt32(), Vector512<int>.AllBitsSet)) 111return Vector512.ConditionalSelect(Vector512.LessThan(x, Vector512<T>.Zero).AsInt32(), 113Vector512.ConditionalSelect(Vector512.GreaterThan(x, Vector512<T>.Zero).AsInt32(), 114Vector512<int>.One, 115Vector512<int>.Zero));

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

105public static Vector512<T> Invoke(Vector512<T> t) 109Vector512<float> x = t.AsSingle(); 111Vector512<float> y = Vector512.Abs(x); 112Vector512<float> z = ExpOperator<float>.Invoke(y - Vector512.Create((float)Single_LOGV)); 113Vector512<float> result = Vector512.Create((float)Single_HALFV) * (z - (Vector512.Create((float)Single_INVV2) / z)); 114Vector512<uint> sign = x.AsUInt32() & Vector512.Create(~(uint)int.MaxValue); 120Vector512<double> x = t.AsDouble(); 122Vector512<double> y = Vector512.Abs(x); 123Vector512<double> z = ExpOperator<double>.Invoke(y - Vector512.Create(Double_LOGV)); 124Vector512<double> result = Vector512.Create(Double_HALFV) * (z - (Vector512.Create(Double_INVV2) / z)); 125Vector512<ulong> sign = x.AsUInt64() & Vector512.Create(~(ulong)long.MaxValue);

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

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

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

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

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

87public static Vector512<T> Invoke(Vector512<T> x) 191public static Vector512<float> Invoke(Vector512<float> x) 193Vector512<float> uxMasked = Vector512.Abs(x); 199Vector512<float> dn = MultiplyAddEstimateOperator<float>.Invoke(uxMasked, Vector512.Create(2 / float.Pi), Vector512.Create(AlmHuge)); 200Vector512<uint> odd = dn.AsUInt32() << 31; 203Vector512<float> f = uxMasked; 209Vector512<float> f2 = f * f; 210Vector512<float> f4 = f2 * f2; 211Vector512<float> f8 = f4 * f4; 212Vector512<float> f12 = f8 * f4; 213Vector512<float> a1 = MultiplyAddEstimateOperator<float>.Invoke(Vector512.Create(C2), f2, Vector512.Create(C1)); 214Vector512<float> a2 = MultiplyAddEstimateOperator<float>.Invoke(Vector512.Create(C4), f2, Vector512.Create(C3)); 215Vector512<float> a3 = MultiplyAddEstimateOperator<float>.Invoke(Vector512.Create(C6), f2, Vector512.Create(C5)); 216Vector512<float> b1 = MultiplyAddEstimateOperator<float>.Invoke(a2, f4, a1); 217Vector512<float> b2 = MultiplyAddEstimateOperator<float>.Invoke(f8, a3, f12 * Vector512.Create(C7)); 218Vector512<float> poly = MultiplyAddEstimateOperator<float>.Invoke(f * f2, b1 + b2, f); 220Vector512<float> result = (poly.AsUInt32() ^ (x.AsUInt32() & Vector512.Create(~SignMask))).AsSingle(); 221return Vector512.ConditionalSelect(Vector512.Equals(odd, Vector512<uint>.Zero).AsSingle(), 348public static Vector512<double> Invoke(Vector512<double> x) 350Vector512<double> uxMasked = Vector512.Abs(x); 357Vector512<double> dn = MultiplyAddEstimateOperator<double>.Invoke(uxMasked, Vector512.Create(2 / double.Pi), Vector512.Create(AlmHuge)); 358Vector512<ulong> odd = dn.AsUInt64() << 63; 362Vector512<double> f = uxMasked; 368Vector512<double> g = f * f; 369Vector512<double> g2 = g * g; 370Vector512<double> g3 = g * g2; 371Vector512<double> g5 = g3 * g2; 372Vector512<double> g7 = g5 * g2; 373Vector512<double> g9 = g7 * g2; 374Vector512<double> g11 = g9 * g2; 375Vector512<double> g13 = g11 * g2; 376Vector512<double> a1 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C3), g, Vector512.Create(C1)); 377Vector512<double> a2 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C7), g, Vector512.Create(C5)); 378Vector512<double> a3 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C11), g, Vector512.Create(C9)); 379Vector512<double> a4 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C15), g, Vector512.Create(C13)); 380Vector512<double> a5 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C19), g, Vector512.Create(C17)); 381Vector512<double> a6 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C23), g, Vector512.Create(C21)); 382Vector512<double> a7 = MultiplyAddEstimateOperator<double>.Invoke(Vector512.Create(C27), g, Vector512.Create(C25)); 383Vector512<double> b1 = MultiplyAddEstimateOperator<double>.Invoke(g, a1, g3 * a2); 384Vector512<double> b2 = MultiplyAddEstimateOperator<double>.Invoke(g5, a3, g7 * a4); 385Vector512<double> b3 = MultiplyAddEstimateOperator<double>.Invoke(g9, a5, g11 * a6); 386Vector512<double> q = MultiplyAddEstimateOperator<double>.Invoke(g13, a7, b1 + b2 + b3); 387Vector512<double> poly = MultiplyAddEstimateOperator<double>.Invoke(f, q, f); 389Vector512<double> result = (poly.AsUInt64() ^ (x.AsUInt64() & Vector512.Create(~SignMask))).AsDouble(); 390return Vector512.ConditionalSelect(Vector512.Equals(odd, Vector512<ulong>.Zero).AsDouble(),

107public static Vector512<T> Invoke(Vector512<T> t) 111Vector512<float> x = t.AsSingle(); 113Vector512<float> y = Vector512.Abs(x); 114Vector512<float> z = ExpM1Operator<float>.Invoke(Vector512.Create(-2f) * y); 115Vector512<uint> sign = x.AsUInt32() & Vector512.Create(~(uint)int.MaxValue); 120Vector512<double> x = t.AsDouble(); 122Vector512<double> y = Vector512.Abs(x); 123Vector512<double> z = ExpM1Operator<double>.Invoke(Vector512.Create(-2d) * y); 124Vector512<ulong> sign = x.AsUInt64() & Vector512.Create(~(ulong)long.MaxValue);

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

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

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

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

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

382if (sizeof(Vector<double>) == sizeof(Vector512<double>)) 405if (sizeof(Vector<double>) == sizeof(Vector512<double>)) 513if (sizeof(Vector<float>) == sizeof(Vector512<float>)) 680if (sizeof(Vector<T>) == sizeof(Vector512<T>)) 1337if (sizeof(Vector<T>) == sizeof(Vector512<T>)) 1583if (sizeof(Vector<T>) == sizeof(Vector512<T>)) 2675if (sizeof(Vector<uint>) == sizeof(Vector512<uint>)) 2701if (sizeof(Vector<ulong>) == sizeof(Vector512<ulong>))

755return VectorMath.CosSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 1660return VectorMath.ExpSingle<Vector256<float>, Vector256<uint>, Vector512<double>, Vector512<ulong>>(vector); 1912return VectorMath.HypotSingle<Vector256<float>, Vector512<double>>(x, y); 3674return VectorMath.SinSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 3718return VectorMath.SinCosSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 3860/// <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> 3863/// <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> 3866public static Vector512<T> ToVector512<T>(this Vector256<T> vector) 3870Vector512<T> result = default; 3875/// <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> 3878/// <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> 3881public static unsafe Vector512<T> ToVector512Unsafe<T>(this Vector256<T> vector) 3888Unsafe.SkipInit(out Vector512<T> result);

63public static Vector512<T> Abs<T>(Vector512<T> vector) 89public static Vector512<T> Add<T>(Vector512<T> left, Vector512<T> right) => left + right; 94public static bool All<T>(Vector512<T> vector, T value) => vector == Create(value); 99public static bool AllWhereAllBitsSet<T>(Vector512<T> vector) 123public static Vector512<T> AndNot<T>(Vector512<T> left, Vector512<T> right) => left & ~right; 128public static bool Any<T>(Vector512<T> vector, T value) => EqualsAny(vector, Create(value)); 133public static bool AnyWhereAllBitsSet<T>(Vector512<T> vector) 157public static Vector512<TTo> As<TFrom, TTo>(this Vector512<TFrom> vector) 165return Unsafe.BitCast<Vector512<TFrom>, Vector512<TTo>>(vector); 169/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Byte&gt;" />.</summary> 175public static Vector512<byte> AsByte<T>(this Vector512<T> vector) => vector.As<T, byte>(); 177/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Double&gt;" />.</summary> 183public static Vector512<double> AsDouble<T>(this Vector512<T> vector) => vector.As<T, double>(); 185/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Int16&gt;" />.</summary> 191public static Vector512<short> AsInt16<T>(this Vector512<T> vector) => vector.As<T, short>(); 193/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Int32&gt;" />.</summary> 199public static Vector512<int> AsInt32<T>(this Vector512<T> vector) => vector.As<T, int>(); 201/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Int64&gt;" />.</summary> 207public static Vector512<long> AsInt64<T>(this Vector512<T> vector) => vector.As<T, long>(); 209/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;IntPtr&gt;" />.</summary> 215public static Vector512<nint> AsNInt<T>(this Vector512<T> vector) => vector.As<T, nint>(); 217/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UIntPtr&gt;" />.</summary> 224public static Vector512<nuint> AsNUInt<T>(this Vector512<T> vector) => vector.As<T, nuint>(); 226/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;SByte&gt;" />.</summary> 233public static Vector512<sbyte> AsSByte<T>(this Vector512<T> vector) => vector.As<T, sbyte>(); 235/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;Single&gt;" />.</summary> 241public static Vector512<float> AsSingle<T>(this Vector512<T> vector) => vector.As<T, float>(); 243/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UInt16&gt;" />.</summary> 250public static Vector512<ushort> AsUInt16<T>(this Vector512<T> vector) => vector.As<T, ushort>(); 252/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UInt32&gt;" />.</summary> 259public static Vector512<uint> AsUInt32<T>(this Vector512<T> vector) => vector.As<T, uint>(); 261/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see langword="Vector512&lt;UInt64&gt;" />.</summary> 268public static Vector512<ulong> AsUInt64<T>(this Vector512<T> vector) => vector.As<T, ulong>(); 270/// <summary>Reinterprets a <see cref="Vector{T}" /> as a new <see cref="Vector512{T}" />.</summary> 273/// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector512{T}" />.</returns> 277public static Vector512<T> AsVector512<T>(this Vector<T> value) 279Debug.Assert(Vector512<T>.Count >= Vector<T>.Count); 282Vector512<T> result = default; 283Unsafe.WriteUnaligned(ref Unsafe.As<Vector512<T>, byte>(ref result), value); 287/// <summary>Reinterprets a <see cref="Vector512{T}" /> as a new <see cref="Vector{T}" />.</summary> 294public static Vector<T> AsVector<T>(this Vector512<T> value) 296Debug.Assert(Vector512<T>.Count >= Vector<T>.Count); 299ref byte address = ref Unsafe.As<Vector512<T>, byte>(ref value); 310public static Vector512<T> BitwiseAnd<T>(Vector512<T> left, Vector512<T> right) => left & right; 319public static Vector512<T> BitwiseOr<T>(Vector512<T> left, Vector512<T> right) => left | right; 326internal static Vector512<T> Ceiling<T>(Vector512<T> vector) 355public static Vector512<float> Ceiling(Vector512<float> vector) => Ceiling<float>(vector); 362public static Vector512<double> Ceiling(Vector512<double> vector) => Ceiling<double>(vector); 366public static Vector512<T> Clamp<T>(Vector512<T> value, Vector512<T> min, Vector512<T> max) 374public static Vector512<T> ClampNative<T>(Vector512<T> value, Vector512<T> min, Vector512<T> max) 390public static Vector512<T> ConditionalSelect<T>(Vector512<T> condition, Vector512<T> left, Vector512<T> right) => (left & condition) | AndNot(right, condition); 397public static Vector512<double> ConvertToDouble(Vector512<long> vector) 411public static Vector512<double> ConvertToDouble(Vector512<ulong> vector) 424public static Vector512<int> ConvertToInt32(Vector512<float> vector) 437public static Vector512<int> ConvertToInt32Native(Vector512<float> vector) 450public static Vector512<long> ConvertToInt64(Vector512<double> vector) 463public static Vector512<long> ConvertToInt64Native(Vector512<double> vector) 476public static Vector512<float> ConvertToSingle(Vector512<int> vector) 490public static Vector512<float> ConvertToSingle(Vector512<uint> vector) 504public static Vector512<uint> ConvertToUInt32(Vector512<float> vector) 518public static Vector512<uint> ConvertToUInt32Native(Vector512<float> vector) 532public static Vector512<ulong> ConvertToUInt64(Vector512<double> vector) 546public static Vector512<ulong> ConvertToUInt64Native(Vector512<double> vector) 557public static Vector512<T> CopySign<T>(Vector512<T> value, Vector512<T> sign) 569return VectorMath.CopySign<Vector512<T>, T>(value, sign); 580/// <summary>Copies a <see cref="Vector512{T}" /> to a given array.</summary> 584/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</exception> 587public static void CopyTo<T>(this Vector512<T> vector, T[] destination) 591if (destination.Length < Vector512<T>.Count) 599/// <summary>Copies a <see cref="Vector512{T}" /> to a given array starting at the specified index.</summary> 604/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</exception> 608public static void CopyTo<T>(this Vector512<T> vector, T[] destination, int startIndex) 617if ((destination.Length - startIndex) < Vector512<T>.Count) 625/// <summary>Copies a <see cref="Vector512{T}" /> to a given span.</summary> 629/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector512{T}.Count" />.</exception> 631public static void CopyTo<T>(this Vector512<T> vector, Span<T> destination) 633if ((uint)destination.Length < (uint)Vector512<T>.Count) 643public static Vector512<double> Cos(Vector512<double> vector) 647return VectorMath.CosDouble<Vector512<double>, Vector512<long>>(vector); 660public static Vector512<float> Cos(Vector512<float> vector) 664return VectorMath.CosSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 678public static int Count<T>(Vector512<T> vector, T value) => BitOperations.PopCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 683public static int CountWhereAllBitsSet<T>(Vector512<T> vector) 699/// <summary>Creates a new <see cref="Vector512{T}" /> instance with all elements initialized to the specified value.</summary> 702/// <returns>A new <see cref="Vector512{T}" /> with all elements initialized to <paramref name="value" />.</returns> 705public static Vector512<T> Create<T>(T value) 716public static Vector512<byte> Create(byte value) => Create<byte>(value); 723public static Vector512<double> Create(double value) => Create<double>(value); 730public static Vector512<short> Create(short value) => Create<short>(value); 737public static Vector512<int> Create(int value) => Create<int>(value); 744public static Vector512<long> Create(long value) => Create<long>(value); 750public static Vector512<nint> Create(nint value) => Create<nint>(value); 757public static Vector512<nuint> Create(nuint value) => Create<nuint>(value); 765public static Vector512<sbyte> Create(sbyte value) => Create<sbyte>(value); 772public static Vector512<float> Create(float value) => Create<float>(value); 780public static Vector512<ushort> Create(ushort value) => Create<ushort>(value); 788public static Vector512<uint> Create(uint value) => Create<uint>(value); 796public static Vector512<ulong> Create(ulong value) => Create<ulong>(value); 798/// <summary>Creates a new <see cref="Vector512{T}" /> from a given array.</summary> 801/// <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> 802/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" /> is less than <see cref="Vector512{T}.Count" />.</exception> 805public static Vector512<T> Create<T>(T[] values) 809if (values.Length < Vector512<T>.Count) 814return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref values[0])); 817/// <summary>Creates a new <see cref="Vector512{T}" /> from a given array.</summary> 821/// <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> 822/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" />, starting from <paramref name="index" />, is less than <see cref="Vector512{T}.Count" />.</exception> 825public static Vector512<T> Create<T>(T[] values, int index) 829if ((index < 0) || ((values.Length - index) < Vector512<T>.Count)) 834return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref values[index])); 837/// <summary>Creates a new <see cref="Vector512{T}" /> from a given readonly span.</summary> 840/// <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> 841/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" /> is less than <see cref="Vector512{T}.Count" />.</exception> 844public static Vector512<T> Create<T>(ReadOnlySpan<T> values) 846if (values.Length < Vector512<T>.Count) 851return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 923public 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, 947public static Vector512<double> Create(double e0, double e1, double e2, double e3, double e4, double e5, double e6, double e7) 992public 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, 1022public 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) 1043public static Vector512<long> Create(long e0, long e1, long e2, long e3, long e4, long e5, long e6, long e7) 1121public 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, 1153public 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) 1199public 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, 1230public 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) 1252public static Vector512<ulong> Create(ulong e0, ulong e1, ulong e2, ulong e3, ulong e4, ulong e5, ulong e6, ulong e7) 1260/// <summary>Creates a new <see cref="Vector512{T}" /> instance with all 64-bit parts initialized to a specified value.</summary> 1266public static Vector512<T> Create<T>(Vector64<T> value) => Create(Vector128.Create(value, value)); 1268/// <summary>Creates a new <see cref="Vector512{T}" /> instance with all 128-bit parts initialized to a specified value.</summary> 1274public static Vector512<T> Create<T>(Vector128<T> value) => Create(Vector256.Create(value, value)); 1276/// <summary>Creates a new <see cref="Vector512{T}" /> instance with the lower and upper 256-bits initialized to a specified value.</summary> 1282public static Vector512<T> Create<T>(Vector256<T> value) => Create(value, value); 1284/// <summary>Creates a new <see cref="Vector512{T}" /> instance from two <see cref="Vector256{T}" /> instances.</summary> 1288/// <returns>A new <see cref="Vector512{T}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns> 1291public static Vector512<T> Create<T>(Vector256<T> lower, Vector256<T> upper) 1294Unsafe.SkipInit(out Vector512<T> result); 1306public static Vector512<byte> Create(Vector256<byte> lower, Vector256<byte> upper) => Create<byte>(lower, upper); 1313public static Vector512<double> Create(Vector256<double> lower, Vector256<double> upper) => Create<double>(lower, upper); 1319public static Vector512<short> Create(Vector256<short> lower, Vector256<short> upper) => Create<short>(lower, upper); 1326public static Vector512<int> Create(Vector256<int> lower, Vector256<int> upper) => Create<int>(lower, upper); 1332public static Vector512<long> Create(Vector256<long> lower, Vector256<long> upper) => Create<long>(lower, upper); 1338public static Vector512<nint> Create(Vector256<nint> lower, Vector256<nint> upper) => Create<nint>(lower, upper); 1345public static Vector512<nuint> Create(Vector256<nuint> lower, Vector256<nuint> upper) => Create<nuint>(lower, upper); 1352public static Vector512<sbyte> Create(Vector256<sbyte> lower, Vector256<sbyte> upper) => Create<sbyte>(lower, upper); 1359public static Vector512<float> Create(Vector256<float> lower, Vector256<float> upper) => Create<float>(lower, upper); 1366public static Vector512<ushort> Create(Vector256<ushort> lower, Vector256<ushort> upper) => Create<ushort>(lower, upper); 1374public static Vector512<uint> Create(Vector256<uint> lower, Vector256<uint> upper) => Create<uint>(lower, upper); 1381public static Vector512<ulong> Create(Vector256<ulong> lower, Vector256<ulong> upper) => Create<ulong>(lower, upper); 1383/// <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> 1386/// <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> 1389public static Vector512<T> CreateScalar<T>(T value) => Vector256.CreateScalar(value).ToVector512(); 1395public static Vector512<byte> CreateScalar(byte value) => CreateScalar<byte>(value); 1401public static Vector512<double> CreateScalar(double value) => CreateScalar<double>(value); 1407public static Vector512<short> CreateScalar(short value) => CreateScalar<short>(value); 1413public static Vector512<int> CreateScalar(int value) => CreateScalar<int>(value); 1419public static Vector512<long> CreateScalar(long value) => CreateScalar<long>(value); 1425public static Vector512<nint> CreateScalar(nint value) => CreateScalar<nint>(value); 1432public static Vector512<nuint> CreateScalar(nuint value) => CreateScalar<nuint>(value); 1439public static Vector512<sbyte> CreateScalar(sbyte value) => CreateScalar<sbyte>(value); 1445public static Vector512<float> CreateScalar(float value) => CreateScalar<float>(value); 1452public static Vector512<ushort> CreateScalar(ushort value) => CreateScalar<ushort>(value); 1459public static Vector512<uint> CreateScalar(uint value) => CreateScalar<uint>(value); 1466public static Vector512<ulong> CreateScalar(ulong value) => CreateScalar<ulong>(value); 1468/// <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> 1471/// <returns>A new <see cref="Vector512{T}" /> instance with the first element initialized to <paramref name="value" /> and the remaining elements left uninitialized.</returns> 1475public static Vector512<T> CreateScalarUnsafe<T>(T value) 1481Unsafe.SkipInit(out Vector512<T> result); 1491public static Vector512<byte> CreateScalarUnsafe(byte value) => CreateScalarUnsafe<byte>(value); 1497public static Vector512<double> CreateScalarUnsafe(double value) => CreateScalarUnsafe<double>(value); 1503public static Vector512<short> CreateScalarUnsafe(short value) => CreateScalarUnsafe<short>(value); 1509public static Vector512<int> CreateScalarUnsafe(int value) => CreateScalarUnsafe<int>(value); 1515public static Vector512<long> CreateScalarUnsafe(long value) => CreateScalarUnsafe<long>(value); 1521public static Vector512<nint> CreateScalarUnsafe(nint value) => CreateScalarUnsafe<nint>(value); 1528public static Vector512<nuint> CreateScalarUnsafe(nuint value) => CreateScalarUnsafe<nuint>(value); 1535public static Vector512<sbyte> CreateScalarUnsafe(sbyte value) => CreateScalarUnsafe<sbyte>(value); 1541public static Vector512<float> CreateScalarUnsafe(float value) => CreateScalarUnsafe<float>(value); 1548public static Vector512<ushort> CreateScalarUnsafe(ushort value) => CreateScalarUnsafe<ushort>(value); 1555public static Vector512<uint> CreateScalarUnsafe(uint value) => CreateScalarUnsafe<uint>(value); 1562public static Vector512<ulong> CreateScalarUnsafe(ulong value) => CreateScalarUnsafe<ulong>(value); 1564/// <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> 1568/// <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> 1571public static Vector512<T> CreateSequence<T>(T start, T step) => (Vector512<T>.Indices * step) + Create(start); 1576public static Vector512<double> DegreesToRadians(Vector512<double> degrees) 1580return VectorMath.DegreesToRadians<Vector512<double>, double>(degrees); 1594public static Vector512<float> DegreesToRadians(Vector512<float> degrees) 1598return VectorMath.DegreesToRadians<Vector512<float>, float>(degrees); 1617public static Vector512<T> Divide<T>(Vector512<T> left, Vector512<T> right) => left / right; 1625public static Vector512<T> Divide<T>(Vector512<T> left, T right) => left / right; 1635public static T Dot<T>(Vector512<T> left, Vector512<T> right) => Sum(left * right); 1645public static Vector512<T> Equals<T>(Vector512<T> left, Vector512<T> right) 1660public static bool EqualsAll<T>(Vector512<T> left, Vector512<T> right) => left == right; 1670public static bool EqualsAny<T>(Vector512<T> left, Vector512<T> right) 1678public static Vector512<double> Exp(Vector512<double> vector) 1682return VectorMath.ExpDouble<Vector512<double>, Vector512<ulong>>(vector); 1695public static Vector512<float> Exp(Vector512<float> vector) 1699return VectorMath.ExpSingle<Vector512<float>, Vector512<uint>, Vector512<double>, Vector512<ulong>>(vector); 1718public static ulong ExtractMostSignificantBits<T>(this Vector512<T> vector) 1730internal static Vector512<T> Floor<T>(Vector512<T> vector) 1759public static Vector512<float> Floor(Vector512<float> vector) => Floor<float>(vector); 1766public static Vector512<double> Floor(Vector512<double> vector) => Floor<double>(vector); 1771public static Vector512<double> FusedMultiplyAdd(Vector512<double> left, Vector512<double> right, Vector512<double> addend) 1782public static Vector512<float> FusedMultiplyAdd(Vector512<float> left, Vector512<float> right, Vector512<float> addend) 1799public static T GetElement<T>(this Vector512<T> vector, int index) 1801if ((uint)(index) >= (uint)(Vector512<T>.Count)) 1815public static Vector256<T> GetLower<T>(this Vector512<T> vector) 1827public static Vector256<T> GetUpper<T>(this Vector512<T> vector) 1841public static Vector512<T> GreaterThan<T>(Vector512<T> left, Vector512<T> right) 1857public static bool GreaterThanAll<T>(Vector512<T> left, Vector512<T> right) 1871public static bool GreaterThanAny<T>(Vector512<T> left, Vector512<T> right) 1885public static Vector512<T> GreaterThanOrEqual<T>(Vector512<T> left, Vector512<T> right) 1901public static bool GreaterThanOrEqualAll<T>(Vector512<T> left, Vector512<T> right) 1915public static bool GreaterThanOrEqualAny<T>(Vector512<T> left, Vector512<T> right) 1923public static Vector512<double> Hypot(Vector512<double> x, Vector512<double> y) 1927return VectorMath.HypotDouble<Vector512<double>, Vector512<ulong>>(x, y); 1940public static Vector512<float> Hypot(Vector512<float> x, Vector512<float> y) 1944return VectorMath.HypotSingle<Vector512<float>, Vector512<double>>(x, y); 1958public static int IndexOf<T>(Vector512<T> vector, T value) 1967public static int IndexOfWhereAllBitsSet<T>(Vector512<T> vector) 1986public static Vector512<T> IsEvenInteger<T>(Vector512<T> vector) 1990return VectorMath.IsEvenIntegerSingle<Vector512<float>, Vector512<uint>>(vector.AsSingle()).As<float, T>(); 1994return VectorMath.IsEvenIntegerDouble<Vector512<double>, Vector512<ulong>>(vector.AsDouble()).As<double, T>(); 1996return IsZero(vector & Vector512<T>.One); 2002public static Vector512<T> IsFinite<T>(Vector512<T> vector) 2012return Vector512<T>.AllBitsSet; 2018public static Vector512<T> IsInfinity<T>(Vector512<T> vector) 2024return Vector512<T>.Zero; 2030public static Vector512<T> IsInteger<T>(Vector512<T> vector) 2036return Vector512<T>.AllBitsSet; 2042public static Vector512<T> IsNaN<T>(Vector512<T> vector) 2048return Vector512<T>.Zero; 2054public static Vector512<T> IsNegative<T>(Vector512<T> vector) 2062return Vector512<T>.Zero; 2066return LessThan(vector.AsInt32(), Vector512<int>.Zero).As<int, T>(); 2070return LessThan(vector.AsInt64(), Vector512<long>.Zero).As<long, T>(); 2074return LessThan(vector, Vector512<T>.Zero); 2081public static Vector512<T> IsNegativeInfinity<T>(Vector512<T> vector) 2091return Vector512<T>.Zero; 2097public static Vector512<T> IsNormal<T>(Vector512<T> vector) 2113public static Vector512<T> IsOddInteger<T>(Vector512<T> vector) 2117return VectorMath.IsOddIntegerSingle<Vector512<float>, Vector512<uint>>(vector.AsSingle()).As<float, T>(); 2121return VectorMath.IsOddIntegerDouble<Vector512<double>, Vector512<ulong>>(vector.AsDouble()).As<double, T>(); 2123return ~IsZero(vector & Vector512<T>.One); 2129public static Vector512<T> IsPositive<T>(Vector512<T> vector) 2137return Vector512<T>.AllBitsSet; 2141return GreaterThanOrEqual(vector.AsInt32(), Vector512<int>.Zero).As<int, T>(); 2145return GreaterThanOrEqual(vector.AsInt64(), Vector512<long>.Zero).As<long, T>(); 2149return GreaterThanOrEqual(vector, Vector512<T>.Zero); 2156public static Vector512<T> IsPositiveInfinity<T>(Vector512<T> vector) 2166return Vector512<T>.Zero; 2172public static Vector512<T> IsSubnormal<T>(Vector512<T> vector) 2176return LessThan(Abs(vector).AsUInt32() - Vector512<uint>.One, Create<uint>(float.MaxTrailingSignificand)).As<uint, T>(); 2180return LessThan(Abs(vector).AsUInt64() - Vector512<ulong>.One, Create<ulong>(double.MaxTrailingSignificand)).As<ulong, T>(); 2182return Vector512<T>.Zero; 2188public static Vector512<T> IsZero<T>(Vector512<T> vector) => Equals(vector, Vector512<T>.Zero); 2193public static int LastIndexOf<T>(Vector512<T> vector, T value) => 63 - BitOperations.LeadingZeroCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 2198public static int LastIndexOfWhereAllBitsSet<T>(Vector512<T> vector) 2217public static Vector512<double> Lerp(Vector512<double> x, Vector512<double> y, Vector512<double> amount) 2221return VectorMath.Lerp<Vector512<double>, double>(x, y, amount); 2235public static Vector512<float> Lerp(Vector512<float> x, Vector512<float> y, Vector512<float> amount) 2239return VectorMath.Lerp<Vector512<float>, float>(x, y, amount); 2258public static Vector512<T> LessThan<T>(Vector512<T> left, Vector512<T> right) 2274public static bool LessThanAll<T>(Vector512<T> left, Vector512<T> right) 2288public static bool LessThanAny<T>(Vector512<T> left, Vector512<T> right) 2302public static Vector512<T> LessThanOrEqual<T>(Vector512<T> left, Vector512<T> right) 2318public static bool LessThanOrEqualAll<T>(Vector512<T> left, Vector512<T> right) 2332public static bool LessThanOrEqualAny<T>(Vector512<T> left, Vector512<T> right) 2345public static Vector512<T> Load<T>(T* source) => LoadUnsafe(ref *source); 2355public static Vector512<T> LoadAligned<T>(T* source) 2364return *(Vector512<T>*)(source); 2375public static Vector512<T> LoadAlignedNonTemporal<T>(T* source) => LoadAligned(source); 2384public static Vector512<T> LoadUnsafe<T>(ref readonly T source) 2388return Unsafe.ReadUnaligned<Vector512<T>>(in address); 2400public static Vector512<T> LoadUnsafe<T>(ref readonly T source, nuint elementOffset) 2404return Unsafe.ReadUnaligned<Vector512<T>>(in address); 2410internal static Vector512<ushort> LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source)); 2416internal static Vector512<ushort> LoadUnsafe(ref char source, nuint elementOffset) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source), elementOffset); 2420public static Vector512<double> Log(Vector512<double> vector) 2424return VectorMath.LogDouble<Vector512<double>, Vector512<long>, Vector512<ulong>>(vector); 2437public static Vector512<float> Log(Vector512<float> vector) 2441return VectorMath.LogSingle<Vector512<float>, Vector512<int>, Vector512<uint>>(vector); 2454public static Vector512<double> Log2(Vector512<double> vector) 2458return VectorMath.Log2Double<Vector512<double>, Vector512<long>, Vector512<ulong>>(vector); 2471public static Vector512<float> Log2(Vector512<float> vector) 2475return VectorMath.Log2Single<Vector512<float>, Vector512<int>, Vector512<uint>>(vector); 2489public static Vector512<T> Max<T>(Vector512<T> left, Vector512<T> right) 2493return VectorMath.Max<Vector512<T>, T>(left, right); 2507public static Vector512<T> MaxMagnitude<T>(Vector512<T> left, Vector512<T> right) 2511return VectorMath.MaxMagnitude<Vector512<T>, T>(left, right); 2525public static Vector512<T> MaxMagnitudeNumber<T>(Vector512<T> left, Vector512<T> right) 2529return VectorMath.MaxMagnitudeNumber<Vector512<T>, T>(left, right); 2543public static Vector512<T> MaxNative<T>(Vector512<T> left, Vector512<T> right) 2561public static Vector512<T> MaxNumber<T>(Vector512<T> left, Vector512<T> right) 2565return VectorMath.MaxNumber<Vector512<T>, T>(left, right); 2579public static Vector512<T> Min<T>(Vector512<T> left, Vector512<T> right) 2583return VectorMath.Min<Vector512<T>, T>(left, right); 2597public static Vector512<T> MinMagnitude<T>(Vector512<T> left, Vector512<T> right) 2601return VectorMath.MinMagnitude<Vector512<T>, T>(left, right); 2615public static Vector512<T> MinMagnitudeNumber<T>(Vector512<T> left, Vector512<T> right) 2619return VectorMath.MinMagnitudeNumber<Vector512<T>, T>(left, right); 2633public static Vector512<T> MinNative<T>(Vector512<T> left, Vector512<T> right) 2651public static Vector512<T> MinNumber<T>(Vector512<T> left, Vector512<T> right) 2655return VectorMath.MinNumber<Vector512<T>, T>(left, right); 2673public static Vector512<T> Multiply<T>(Vector512<T> left, Vector512<T> right) => left * right; 2682public static Vector512<T> Multiply<T>(Vector512<T> left, T right) => left * right; 2691public static Vector512<T> Multiply<T>(T left, Vector512<T> right) => right * left; 2695internal static Vector512<T> MultiplyAddEstimate<T>(Vector512<T> left, Vector512<T> right, Vector512<T> addend) 2706public static Vector512<double> MultiplyAddEstimate(Vector512<double> left, Vector512<double> right, Vector512<double> addend) 2716public static Vector512<float> MultiplyAddEstimate(Vector512<float> left, Vector512<float> right, Vector512<float> addend) 2730public static Vector512<float> Narrow(Vector512<double> lower, Vector512<double> upper) 2745public static Vector512<sbyte> Narrow(Vector512<short> lower, Vector512<short> upper) 2759public static Vector512<short> Narrow(Vector512<int> lower, Vector512<int> upper) 2773public static Vector512<int> Narrow(Vector512<long> lower, Vector512<long> upper) 2788public static Vector512<byte> Narrow(Vector512<ushort> lower, Vector512<ushort> upper) 2803public static Vector512<ushort> Narrow(Vector512<uint> lower, Vector512<uint> upper) 2818public static Vector512<uint> Narrow(Vector512<ulong> lower, Vector512<ulong> upper) 2832public static Vector512<T> Negate<T>(Vector512<T> vector) => -vector; 2837public static bool None<T>(Vector512<T> vector, T value) => !EqualsAny(vector, Create(value)); 2842public static bool NoneWhereAllBitsSet<T>(Vector512<T> vector) 2864public static Vector512<T> OnesComplement<T>(Vector512<T> vector) => ~vector; 2869public static Vector512<double> RadiansToDegrees(Vector512<double> radians) 2873return VectorMath.RadiansToDegrees<Vector512<double>, double>(radians); 2887public static Vector512<float> RadiansToDegrees(Vector512<float> radians) 2891return VectorMath.RadiansToDegrees<Vector512<float>, float>(radians); 2904internal static Vector512<T> Round<T>(Vector512<T> vector) 2930public static Vector512<double> Round(Vector512<double> vector) => Round<double>(vector); 2934public static Vector512<float> Round(Vector512<float> vector) => Round<float>(vector); 2938public static Vector512<double> Round(Vector512<double> vector, MidpointRounding mode) => VectorMath.RoundDouble(vector, mode); 2942public static Vector512<float> Round(Vector512<float> vector, MidpointRounding mode) => VectorMath.RoundSingle(vector, mode); 2949internal static Vector512<T> ShiftLeft<T>(Vector512<T> vector, int shiftCount) => vector << shiftCount; 2956public static Vector512<byte> ShiftLeft(Vector512<byte> vector, int shiftCount) => vector << shiftCount; 2963public static Vector512<short> ShiftLeft(Vector512<short> vector, int shiftCount) => vector << shiftCount; 2970public static Vector512<int> ShiftLeft(Vector512<int> vector, int shiftCount) => vector << shiftCount; 2977public static Vector512<long> ShiftLeft(Vector512<long> vector, int shiftCount) => vector << shiftCount; 2984public static Vector512<nint> ShiftLeft(Vector512<nint> vector, int shiftCount) => vector << shiftCount; 2992public static Vector512<nuint> ShiftLeft(Vector512<nuint> vector, int shiftCount) => vector << shiftCount; 3000public static Vector512<sbyte> ShiftLeft(Vector512<sbyte> vector, int shiftCount) => vector << shiftCount; 3008public static Vector512<ushort> ShiftLeft(Vector512<ushort> vector, int shiftCount) => vector << shiftCount; 3016public static Vector512<uint> ShiftLeft(Vector512<uint> vector, int shiftCount) => vector << shiftCount; 3019internal static Vector512<uint> ShiftLeft(Vector512<uint> vector, Vector512<uint> shiftCount) 3033public static Vector512<ulong> ShiftLeft(Vector512<ulong> vector, int shiftCount) => vector << shiftCount; 3036internal static Vector512<ulong> ShiftLeft(Vector512<ulong> vector, Vector512<ulong> shiftCount) 3049internal static Vector512<T> ShiftRightArithmetic<T>(Vector512<T> vector, int shiftCount) => vector >> shiftCount; 3056public static Vector512<short> ShiftRightArithmetic(Vector512<short> vector, int shiftCount) => vector >> shiftCount; 3063public static Vector512<int> ShiftRightArithmetic(Vector512<int> vector, int shiftCount) => vector >> shiftCount; 3070public static Vector512<long> ShiftRightArithmetic(Vector512<long> vector, int shiftCount) => vector >> shiftCount; 3077public static Vector512<nint> ShiftRightArithmetic(Vector512<nint> vector, int shiftCount) => vector >> shiftCount; 3085public static Vector512<sbyte> ShiftRightArithmetic(Vector512<sbyte> vector, int shiftCount) => vector >> shiftCount; 3092internal static Vector512<T> ShiftRightLogical<T>(Vector512<T> vector, int shiftCount) => vector >>> shiftCount; 3099public static Vector512<byte> ShiftRightLogical(Vector512<byte> vector, int shiftCount) => vector >>> shiftCount; 3106public static Vector512<short> ShiftRightLogical(Vector512<short> vector, int shiftCount) => vector >>> shiftCount; 3113public static Vector512<int> ShiftRightLogical(Vector512<int> vector, int shiftCount) => vector >>> shiftCount; 3120public static Vector512<long> ShiftRightLogical(Vector512<long> vector, int shiftCount) => vector >>> shiftCount; 3127public static Vector512<nint> ShiftRightLogical(Vector512<nint> vector, int shiftCount) => vector >>> shiftCount; 3135public static Vector512<nuint> ShiftRightLogical(Vector512<nuint> vector, int shiftCount) => vector >>> shiftCount; 3143public static Vector512<sbyte> ShiftRightLogical(Vector512<sbyte> vector, int shiftCount) => vector >>> shiftCount; 3151public static Vector512<ushort> ShiftRightLogical(Vector512<ushort> vector, int shiftCount) => vector >>> shiftCount; 3159public static Vector512<uint> ShiftRightLogical(Vector512<uint> vector, int shiftCount) => vector >>> shiftCount; 3167public static Vector512<ulong> ShiftRightLogical(Vector512<ulong> vector, int shiftCount) => vector >>> shiftCount; 3175internal static Vector512<byte> ShuffleNativeFallback(Vector512<byte> vector, Vector512<byte> indices) 3181internal static Vector512<sbyte> ShuffleNativeFallback(Vector512<sbyte> vector, Vector512<sbyte> indices) 3187internal static Vector512<short> ShuffleNativeFallback(Vector512<short> vector, Vector512<short> indices) 3193internal static Vector512<ushort> ShuffleNativeFallback(Vector512<ushort> vector, Vector512<ushort> indices) 3199internal static Vector512<int> ShuffleNativeFallback(Vector512<int> vector, Vector512<int> indices) 3205internal static Vector512<uint> ShuffleNativeFallback(Vector512<uint> vector, Vector512<uint> indices) 3211internal static Vector512<float> ShuffleNativeFallback(Vector512<float> vector, Vector512<int> indices) 3217internal static Vector512<long> ShuffleNativeFallback(Vector512<long> vector, Vector512<long> indices) 3223internal static Vector512<ulong> ShuffleNativeFallback(Vector512<ulong> vector, Vector512<ulong> indices) 3229internal static Vector512<double> ShuffleNativeFallback(Vector512<double> vector, Vector512<long> indices) 3240public static Vector512<byte> Shuffle(Vector512<byte> vector, Vector512<byte> indices) 3242Unsafe.SkipInit(out Vector512<byte> result); 3244for (int index = 0; index < Vector512<byte>.Count; index++) 3249if (selectedIndex < Vector512<byte>.Count) 3265public static Vector512<sbyte> Shuffle(Vector512<sbyte> vector, Vector512<sbyte> indices) 3267Unsafe.SkipInit(out Vector512<sbyte> result); 3269for (int index = 0; index < Vector512<sbyte>.Count; index++) 3274if (selectedIndex < Vector512<sbyte>.Count) 3295public static Vector512<byte> ShuffleNative(Vector512<byte> vector, Vector512<byte> indices) 3316public static Vector512<sbyte> ShuffleNative(Vector512<sbyte> vector, Vector512<sbyte> indices) 3330public static Vector512<short> Shuffle(Vector512<short> vector, Vector512<short> indices) 3332Unsafe.SkipInit(out Vector512<short> result); 3334for (int index = 0; index < Vector512<short>.Count; index++) 3339if (selectedIndex < Vector512<short>.Count) 3355public static Vector512<ushort> Shuffle(Vector512<ushort> vector, Vector512<ushort> indices) 3357Unsafe.SkipInit(out Vector512<ushort> result); 3359for (int index = 0; index < Vector512<ushort>.Count; index++) 3364if (selectedIndex < Vector512<ushort>.Count) 3384public static Vector512<short> ShuffleNative(Vector512<short> vector, Vector512<short> indices) 3404public static Vector512<ushort> ShuffleNative(Vector512<ushort> vector, Vector512<ushort> indices) 3418public static Vector512<int> Shuffle(Vector512<int> vector, Vector512<int> indices) 3420Unsafe.SkipInit(out Vector512<int> result); 3422for (int index = 0; index < Vector512<int>.Count; index++) 3427if (selectedIndex < Vector512<int>.Count) 3443public static Vector512<uint> Shuffle(Vector512<uint> vector, Vector512<uint> indices) 3445Unsafe.SkipInit(out Vector512<uint> result); 3447for (int index = 0; index < Vector512<uint>.Count; index++) 3452if (selectedIndex < Vector512<uint>.Count) 3467public static Vector512<float> Shuffle(Vector512<float> vector, Vector512<int> indices) 3469Unsafe.SkipInit(out Vector512<float> result); 3471for (int index = 0; index < Vector512<float>.Count; index++) 3476if (selectedIndex < Vector512<float>.Count) 3496public static Vector512<int> ShuffleNative(Vector512<int> vector, Vector512<int> indices) 3516public static Vector512<uint> ShuffleNative(Vector512<uint> vector, Vector512<uint> indices) 3535public static Vector512<float> ShuffleNative(Vector512<float> vector, Vector512<int> indices) 3549public static Vector512<long> Shuffle(Vector512<long> vector, Vector512<long> indices) 3551Unsafe.SkipInit(out Vector512<long> result); 3553for (int index = 0; index < Vector512<long>.Count; index++) 3558if (selectedIndex < (uint)Vector512<long>.Count) 3574public static Vector512<ulong> Shuffle(Vector512<ulong> vector, Vector512<ulong> indices) 3576Unsafe.SkipInit(out Vector512<ulong> result); 3578for (int index = 0; index < Vector512<ulong>.Count; index++) 3583if (selectedIndex < (uint)Vector512<ulong>.Count) 3598public static Vector512<double> Shuffle(Vector512<double> vector, Vector512<long> indices) 3600Unsafe.SkipInit(out Vector512<double> result); 3602for (int index = 0; index < Vector512<double>.Count; index++) 3607if (selectedIndex < (uint)Vector512<double>.Count) 3627public static Vector512<long> ShuffleNative(Vector512<long> vector, Vector512<long> indices) 3647public static Vector512<ulong> ShuffleNative(Vector512<ulong> vector, Vector512<ulong> indices) 3666public static Vector512<double> ShuffleNative(Vector512<double> vector, Vector512<long> indices) 3677public static Vector512<double> Sin(Vector512<double> vector) 3681return VectorMath.SinDouble<Vector512<double>, Vector512<long>>(vector); 3694public static Vector512<float> Sin(Vector512<float> vector) 3698return VectorMath.SinSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 3711public static (Vector512<double> Sin, Vector512<double> Cos) SinCos(Vector512<double> vector) 3715return VectorMath.SinCosDouble<Vector512<double>, Vector512<long>>(vector); 3731public static (Vector512<float> Sin, Vector512<float> Cos) SinCos(Vector512<float> vector) 3735return VectorMath.SinCosSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector); 3756public static Vector512<T> Sqrt<T>(Vector512<T> vector) 3771public static void Store<T>(this Vector512<T> source, T* destination) => source.StoreUnsafe(ref *destination); 3781public static void StoreAligned<T>(this Vector512<T> source, T* destination) 3790*(Vector512<T>*)(destination) = source; 3801public static void StoreAlignedNonTemporal<T>(this Vector512<T> source, T* destination) => source.StoreAligned(destination); 3810public static void StoreUnsafe<T>(this Vector512<T> source, ref T destination) 3826public static void StoreUnsafe<T>(this Vector512<T> source, ref T destination, nuint elementOffset) 3840public static Vector512<T> Subtract<T>(Vector512<T> left, Vector512<T> right) => left - right; 3849public static T Sum<T>(Vector512<T> vector) 3866public static T ToScalar<T>(this Vector512<T> vector) 3874internal static Vector512<T> Truncate<T>(Vector512<T> vector) 3900public static Vector512<double> Truncate(Vector512<double> vector) => Truncate<double>(vector); 3904public static Vector512<float> Truncate(Vector512<float> vector) => Truncate<float>(vector); 3910/// <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> 3912public static bool TryCopyTo<T>(this Vector512<T> vector, Span<T> destination) 3914if ((uint)destination.Length < (uint)Vector512<T>.Count) 3923/// <summary>Widens a <see langword="Vector512&lt;Byte&gt;" /> into two <see cref="Vector512{UInt16} " />.</summary> 3928public static (Vector512<ushort> Lower, Vector512<ushort> Upper) Widen(Vector512<byte> source) => (WidenLower(source), WidenUpper(source)); 3930/// <summary>Widens a <see langword="Vector512&lt;Int16&gt;" /> into two <see cref="Vector512{Int32} " />.</summary> 3934public static (Vector512<int> Lower, Vector512<int> Upper) Widen(Vector512<short> source) => (WidenLower(source), WidenUpper(source)); 3936/// <summary>Widens a <see langword="Vector512&lt;Int32&gt;" /> into two <see cref="Vector512{Int64} " />.</summary> 3940public static (Vector512<long> Lower, Vector512<long> Upper) Widen(Vector512<int> source) => (WidenLower(source), WidenUpper(source)); 3942/// <summary>Widens a <see langword="Vector512&lt;SByte&gt;" /> into two <see cref="Vector512{Int16} " />.</summary> 3947public static (Vector512<short> Lower, Vector512<short> Upper) Widen(Vector512<sbyte> source) => (WidenLower(source), WidenUpper(source)); 3949/// <summary>Widens a <see langword="Vector512&lt;Single&gt;" /> into two <see cref="Vector512{Double} " />.</summary> 3953public static (Vector512<double> Lower, Vector512<double> Upper) Widen(Vector512<float> source) => (WidenLower(source), WidenUpper(source)); 3955/// <summary>Widens a <see langword="Vector512&lt;UInt16&gt;" /> into two <see cref="Vector512{UInt32} " />.</summary> 3960public static (Vector512<uint> Lower, Vector512<uint> Upper) Widen(Vector512<ushort> source) => (WidenLower(source), WidenUpper(source)); 3962/// <summary>Widens a <see langword="Vector512&lt;UInt32&gt;" /> into two <see cref="Vector512{UInt64} " />.</summary> 3967public static (Vector512<ulong> Lower, Vector512<ulong> Upper) Widen(Vector512<uint> source) => (WidenLower(source), WidenUpper(source)); 3969/// <summary>Widens the lower half of a <see langword="Vector512&lt;Byte&gt;" /> into a <see cref="Vector512{UInt16} " />.</summary> 3975public static Vector512<ushort> WidenLower(Vector512<byte> source) 3985/// <summary>Widens the lower half of a <see langword="Vector512&lt;Int16&gt;" /> into a <see cref="Vector512{Int32} " />.</summary> 3990public static Vector512<int> WidenLower(Vector512<short> source) 4000/// <summary>Widens the lower half of a <see langword="Vector512&lt;Int32&gt;" /> into a <see cref="Vector512{Int64} " />.</summary> 4005public static Vector512<long> WidenLower(Vector512<int> source) 4015/// <summary>Widens the lower half of a <see langword="Vector512&lt;SByte&gt;" /> into a <see cref="Vector512{Int16} " />.</summary> 4021public static Vector512<short> WidenLower(Vector512<sbyte> source) 4030/// <summary>Widens the lower half of a <see langword="Vector512&lt;Single&gt;" /> into a <see cref="Vector512{Double} " />.</summary> 4035public static Vector512<double> WidenLower(Vector512<float> source) 4045/// <summary>Widens the lower half of a <see langword="Vector512&lt;UInt16&gt;" /> into a <see cref="Vector512{UInt32} " />.</summary> 4051public static Vector512<uint> WidenLower(Vector512<ushort> source) 4061/// <summary>Widens the lower half of a <see langword="Vector512&lt;UInt32&gt;" /> into a <see cref="Vector512{UInt64} " />.</summary> 4067public static Vector512<ulong> WidenLower(Vector512<uint> source) 4077/// <summary>Widens the upper half of a <see langword="Vector512&lt;Byte&gt;" /> into a <see cref="Vector512{UInt16} " />.</summary> 4083public static Vector512<ushort> WidenUpper(Vector512<byte> source) 4093/// <summary>Widens the upper half of a <see langword="Vector512&lt;Int16&gt;" /> into a <see cref="Vector512{Int32} " />.</summary> 4098public static Vector512<int> WidenUpper(Vector512<short> source) 4108/// <summary>Widens the upper half of a <see langword="Vector512&lt;Int32&gt;" /> into a <see cref="Vector512{Int64} " />.</summary> 4113public static Vector512<long> WidenUpper(Vector512<int> source) 4123/// <summary>Widens the upper half of a <see langword="Vector512&lt;SByte&gt;" /> into a <see cref="Vector512{Int16} " />.</summary> 4129public static Vector512<short> WidenUpper(Vector512<sbyte> source) 4139/// <summary>Widens the upper half of a <see langword="Vector512&lt;Single&gt;" /> into a <see cref="Vector512{Double} " />.</summary> 4144public static Vector512<double> WidenUpper(Vector512<float> source) 4154/// <summary>Widens the upper half of a <see langword="Vector512&lt;UInt16&gt;" /> into a <see cref="Vector512{UInt32} " />.</summary> 4160public static Vector512<uint> WidenUpper(Vector512<ushort> source) 4170/// <summary>Widens the upper half of a <see langword="Vector512&lt;UInt32&gt;" /> into a <see cref="Vector512{UInt64} " />.</summary> 4176public static Vector512<ulong> WidenUpper(Vector512<uint> source) 4186/// <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> 4191/// <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> 4195public static Vector512<T> WithElement<T>(this Vector512<T> vector, int index, T value) 4197if ((uint)(index) >= (uint)(Vector512<T>.Count)) 4202Vector512<T> result = vector; 4207/// <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> 4211/// <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> 4215public static Vector512<T> WithLower<T>(this Vector512<T> vector, Vector256<T> value) 4219Vector512<T> result = vector; 4224/// <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> 4228/// <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> 4232public static Vector512<T> WithUpper<T>(this Vector512<T> vector, Vector256<T> value) 4236Vector512<T> result = vector; 4248public static Vector512<T> Xor<T>(Vector512<T> left, Vector512<T> right) => left ^ right; 4251internal static T GetElementUnsafe<T>(in this Vector512<T> vector, int index) 4253Debug.Assert((index >= 0) && (index < Vector512<T>.Count)); 4254ref T address = ref Unsafe.As<Vector512<T>, T>(ref Unsafe.AsRef(in vector)); 4259internal static void SetElementUnsafe<T>(in this Vector512<T> vector, int index, T value) 4261Debug.Assert((index >= 0) && (index < Vector512<T>.Count)); 4262ref T address = ref Unsafe.As<Vector512<T>, T>(ref Unsafe.AsRef(in vector)); 4266internal static void SetLowerUnsafe<T>(in this Vector512<T> vector, Vector256<T> value) => Unsafe.AsRef(in vector._lower) = value; 4268internal static void SetUpperUnsafe<T>(in this Vector512<T> vector, Vector256<T> value) => Unsafe.AsRef(in vector._upper) = value;

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

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

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

2775public static Vector512<int> DetectConflicts(Vector512<int> value) => DetectConflicts(value); 2781public static Vector512<uint> DetectConflicts(Vector512<uint> value) => DetectConflicts(value); 2787public static Vector512<long> DetectConflicts(Vector512<long> value) => DetectConflicts(value); 2793public static Vector512<ulong> DetectConflicts(Vector512<ulong> value) => DetectConflicts(value); 2799public static Vector512<int> LeadingZeroCount(Vector512<int> value) => LeadingZeroCount(value); 2805public static Vector512<uint> LeadingZeroCount(Vector512<uint> value) => LeadingZeroCount(value); 2811public static Vector512<long> LeadingZeroCount(Vector512<long> value) => LeadingZeroCount(value); 2817public static Vector512<ulong> LeadingZeroCount(Vector512<ulong> value) => LeadingZeroCount(value); 2823public static Vector512<float> And(Vector512<float> left, Vector512<float> right) => And(left, right); 2829public static Vector512<double> And(Vector512<double> left, Vector512<double> right) => And(left, right); 2835public static Vector512<float> AndNot(Vector512<float> left, Vector512<float> right) => AndNot(left, right); 2841public static Vector512<double> AndNot(Vector512<double> left, Vector512<double> right) => AndNot(left, right); 2847public static Vector512<int> BroadcastPairScalarToVector512(Vector128<int> value) => BroadcastPairScalarToVector512(value); 2853public static Vector512<uint> BroadcastPairScalarToVector512(Vector128<uint> value) => BroadcastPairScalarToVector512(value); 2859public static Vector512<float> BroadcastPairScalarToVector512(Vector128<float> value) => BroadcastPairScalarToVector512(value); 2865public static unsafe Vector512<long> BroadcastVector128ToVector512(long* address) => BroadcastVector128ToVector512(address); 2871public static unsafe Vector512<ulong> BroadcastVector128ToVector512(ulong* address) => BroadcastVector128ToVector512(address); 2877public static unsafe Vector512<double> BroadcastVector128ToVector512(double* address) => BroadcastVector128ToVector512(address); 2883public static unsafe Vector512<int> BroadcastVector256ToVector512(int* address) => BroadcastVector256ToVector512(address); 2889public static unsafe Vector512<uint> BroadcastVector256ToVector512(uint* address) => BroadcastVector256ToVector512(address); 2895public static unsafe Vector512<float> BroadcastVector256ToVector512(float* address) => BroadcastVector256ToVector512(address); 2901public static Vector256<float> ConvertToVector256Single(Vector512<long> value) => ConvertToVector256Single(value); 2907public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value) => ConvertToVector256Single(value); 2913public static Vector256<float> ConvertToVector256Single(Vector512<long> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); 2919public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); 2925public static Vector512<double> ConvertToVector512Double(Vector512<long> value) => ConvertToVector512Double(value); 2931public static Vector512<double> ConvertToVector512Double(Vector512<ulong> value) => ConvertToVector512Double(value); 2937public static Vector512<double> ConvertToVector512Double(Vector512<long> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Double(value, mode); 2943public static Vector512<double> ConvertToVector512Double(Vector512<ulong> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Double(value, mode); 2949public static Vector512<long> ConvertToVector512Int64(Vector256<float> value) => ConvertToVector512Int64(value); 2955public static Vector512<long> ConvertToVector512Int64(Vector512<double> value) => ConvertToVector512Int64(value); 2961public static Vector512<long> ConvertToVector512Int64(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int64(value, mode); 2967public static Vector512<long> ConvertToVector512Int64(Vector512<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int64(value, mode); 2973public static Vector512<long> ConvertToVector512Int64WithTruncation(Vector256<float> value) => ConvertToVector512Int64WithTruncation(value); 2979public static Vector512<long> ConvertToVector512Int64WithTruncation(Vector512<double> value) => ConvertToVector512Int64WithTruncation(value); 2985public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value) => ConvertToVector512UInt64(value); 2991public static Vector512<ulong> ConvertToVector512UInt64(Vector512<double> value) => ConvertToVector512UInt64(value); 2997public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt64(value, mode); 3003public static Vector512<ulong> ConvertToVector512UInt64(Vector512<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt64(value, mode); 3009public static Vector512<ulong> ConvertToVector512UInt64WithTruncation(Vector256<float> value) => ConvertToVector512UInt64WithTruncation(value); 3015public static Vector512<ulong> ConvertToVector512UInt64WithTruncation(Vector512<double> value) => ConvertToVector512UInt64WithTruncation(value); 3021public static new Vector128<long> ExtractVector128(Vector512<long> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 3027public static new Vector128<ulong> ExtractVector128(Vector512<ulong> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 3033public static new Vector128<double> ExtractVector128(Vector512<double> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 3039public static new Vector256<int> ExtractVector256(Vector512<int> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3045public static new Vector256<uint> ExtractVector256(Vector512<uint> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3051public static new Vector256<float> ExtractVector256(Vector512<float> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3057public static new Vector512<long> InsertVector128(Vector512<long> value, Vector128<long> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 3063public static new Vector512<ulong> InsertVector128(Vector512<ulong> value, Vector128<ulong> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 3069public static new Vector512<double> InsertVector128(Vector512<double> value, Vector128<double> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 3075public static new Vector512<int> InsertVector256(Vector512<int> value, Vector256<int> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 3081public static new Vector512<uint> InsertVector256(Vector512<uint> value, Vector256<uint> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 3087public static new Vector512<float> InsertVector256(Vector512<float> value, Vector256<float> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 3093public static Vector512<long> MultiplyLow(Vector512<long> left, Vector512<long> right) => MultiplyLow(left, right); 3099public static Vector512<ulong> MultiplyLow(Vector512<ulong> left, Vector512<ulong> right) => MultiplyLow(left, right); 3105public static Vector512<byte> MultiShift(Vector512<byte> control, Vector512<ulong> value) => MultiShift(control, value); 3110public static Vector512<sbyte> MultiShift(Vector512<sbyte> control, Vector512<long> value) => MultiShift(control, value); 3116public static Vector512<float> Or(Vector512<float> left, Vector512<float> right) => Or(left, right); 3122public static Vector512<double> Or(Vector512<double> left, Vector512<double> right) => Or(left, right); 3128public static Vector512<float> Range(Vector512<float> left, Vector512<float> right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); 3134public static Vector512<double> Range(Vector512<double> left, Vector512<double> right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); 3140public static Vector512<float> Reduce(Vector512<float> value, [ConstantExpected] byte control) => Reduce(value, control); 3146public static Vector512<double> Reduce(Vector512<double> value, [ConstantExpected] byte control) => Reduce(value, control); 3152public static Vector512<float> Xor(Vector512<float> left, Vector512<float> right) => Xor(left, right); 3158public static Vector512<double> Xor(Vector512<double> left, Vector512<double> right) => Xor(left, right); 3164public static Vector512<sbyte> PermuteVar64x8(Vector512<sbyte> left, Vector512<sbyte> control) => PermuteVar64x8(left, control); 3170public static Vector512<byte> PermuteVar64x8(Vector512<byte> left, Vector512<byte> control) => PermuteVar64x8(left, control); 3177public static Vector512<byte> PermuteVar64x8x2(Vector512<byte> lower, Vector512<byte> indices, Vector512<byte> upper) => PermuteVar64x8x2(lower, indices, upper); 3184public static Vector512<sbyte> PermuteVar64x8x2(Vector512<sbyte> lower, Vector512<sbyte> indices, Vector512<sbyte> upper) => PermuteVar64x8x2(lower, indices, upper);

292public static Vector512<double> MinMax(Vector512<double> left, Vector512<double> right, [ConstantExpected] byte control) => MinMax(left, right, control); 297public static Vector512<float> MinMax(Vector512<float> left, Vector512<float> right, [ConstantExpected] byte control) => MinMax(left, right, control); 302public static Vector512<int> ConvertToSByteWithSaturationAndZeroExtendToInt32(Vector512<float> value) => ConvertToSByteWithSaturationAndZeroExtendToInt32(value); 307public static Vector512<int> ConvertToSByteWithSaturationAndZeroExtendToInt32(Vector512<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToSByteWithSaturationAndZeroExtendToInt32(value, mode); 312public static Vector512<int> ConvertToByteWithSaturationAndZeroExtendToInt32(Vector512<float> value) => ConvertToByteWithSaturationAndZeroExtendToInt32(value); 317public static Vector512<int> ConvertToByteWithSaturationAndZeroExtendToInt32(Vector512<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToByteWithSaturationAndZeroExtendToInt32(value, mode); 322public static Vector512<int> ConvertToSByteWithTruncatedSaturationAndZeroExtendToInt32(Vector512<float> value) => ConvertToSByteWithTruncatedSaturationAndZeroExtendToInt32(value); 327public static Vector512<int> ConvertToByteWithTruncatedSaturationAndZeroExtendToInt32(Vector512<float> value) => ConvertToByteWithTruncatedSaturationAndZeroExtendToInt32(value); 332public static Vector512<ushort> MultipleSumAbsoluteDifferences(Vector512<byte> left, Vector512<byte> right, [ConstantExpected] byte mask) => MultipleSumAbsoluteDifferences(left, right, mask);

411public static Vector512<byte> Abs(Vector512<sbyte> value) => Abs(value); 416public static Vector512<ushort> Abs(Vector512<short> value) => Abs(value); 422public static Vector512<sbyte> Add(Vector512<sbyte> left, Vector512<sbyte> right) => Add(left, right); 427public static Vector512<byte> Add(Vector512<byte> left, Vector512<byte> right) => Add(left, right); 432public static Vector512<short> Add(Vector512<short> left, Vector512<short> right) => Add(left, right); 437public static Vector512<ushort> Add(Vector512<ushort> left, Vector512<ushort> right) => Add(left, right); 443public static Vector512<sbyte> AddSaturate(Vector512<sbyte> left, Vector512<sbyte> right) => AddSaturate(left, right); 448public static Vector512<byte> AddSaturate(Vector512<byte> left, Vector512<byte> right) => AddSaturate(left, right); 453public static Vector512<short> AddSaturate(Vector512<short> left, Vector512<short> right) => AddSaturate(left, right); 458public static Vector512<ushort> AddSaturate(Vector512<ushort> left, Vector512<ushort> right) => AddSaturate(left, right); 464public static Vector512<sbyte> AlignRight(Vector512<sbyte> left, Vector512<sbyte> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); 469public static Vector512<byte> AlignRight(Vector512<byte> left, Vector512<byte> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); 475public static Vector512<byte> Average(Vector512<byte> left, Vector512<byte> right) => Average(left, right); 480public static Vector512<ushort> Average(Vector512<ushort> left, Vector512<ushort> right) => Average(left, right); 486public static Vector512<byte> BlendVariable(Vector512<byte> left, Vector512<byte> right, Vector512<byte> mask) => BlendVariable(left, right, mask); 491public static Vector512<short> BlendVariable(Vector512<short> left, Vector512<short> right, Vector512<short> mask) => BlendVariable(left, right, mask); 496public static Vector512<sbyte> BlendVariable(Vector512<sbyte> left, Vector512<sbyte> right, Vector512<sbyte> mask) => BlendVariable(left, right, mask); 501public static Vector512<ushort> BlendVariable(Vector512<ushort> left, Vector512<ushort> right, Vector512<ushort> mask) => BlendVariable(left, right, mask); 507public static Vector512<byte> BroadcastScalarToVector512(Vector128<byte> value) => BroadcastScalarToVector512(value); 512public static Vector512<sbyte> BroadcastScalarToVector512(Vector128<sbyte> value) => BroadcastScalarToVector512(value); 517public static Vector512<short> BroadcastScalarToVector512(Vector128<short> value) => BroadcastScalarToVector512(value); 522public static Vector512<ushort> BroadcastScalarToVector512(Vector128<ushort> value) => BroadcastScalarToVector512(value); 528public static Vector512<byte> CompareEqual(Vector512<byte> left, Vector512<byte> right) => CompareEqual(left, right); 533public static Vector512<byte> CompareGreaterThan(Vector512<byte> left, Vector512<byte> right) => CompareGreaterThan(left, right); 538public static Vector512<byte> CompareGreaterThanOrEqual(Vector512<byte> left, Vector512<byte> right) => CompareGreaterThanOrEqual(left, right); 543public static Vector512<byte> CompareLessThan(Vector512<byte> left, Vector512<byte> right) => CompareLessThan(left, right); 548public static Vector512<byte> CompareLessThanOrEqual(Vector512<byte> left, Vector512<byte> right) => CompareLessThanOrEqual(left, right); 553public static Vector512<byte> CompareNotEqual(Vector512<byte> left, Vector512<byte> right) => CompareNotEqual(left, right); 559public static Vector512<short> CompareEqual(Vector512<short> left, Vector512<short> right) => CompareEqual(left, right); 564public static Vector512<short> CompareGreaterThan(Vector512<short> left, Vector512<short> right) => CompareGreaterThan(left, right); 569public static Vector512<short> CompareGreaterThanOrEqual(Vector512<short> left, Vector512<short> right) => CompareGreaterThanOrEqual(left, right); 574public static Vector512<short> CompareLessThan(Vector512<short> left, Vector512<short> right) => CompareLessThan(left, right); 579public static Vector512<short> CompareLessThanOrEqual(Vector512<short> left, Vector512<short> right) => CompareLessThanOrEqual(left, right); 584public static Vector512<short> CompareNotEqual(Vector512<short> left, Vector512<short> right) => CompareNotEqual(left, right); 590public static Vector512<sbyte> CompareEqual(Vector512<sbyte> left, Vector512<sbyte> right) => CompareEqual(left, right); 595public static Vector512<sbyte> CompareGreaterThan(Vector512<sbyte> left, Vector512<sbyte> right) => CompareGreaterThan(left, right); 600public static Vector512<sbyte> CompareGreaterThanOrEqual(Vector512<sbyte> left, Vector512<sbyte> right) => CompareGreaterThanOrEqual(left, right); 605public static Vector512<sbyte> CompareLessThan(Vector512<sbyte> left, Vector512<sbyte> right) => CompareLessThan(left, right); 610public static Vector512<sbyte> CompareLessThanOrEqual(Vector512<sbyte> left, Vector512<sbyte> right) => CompareLessThanOrEqual(left, right); 615public static Vector512<sbyte> CompareNotEqual(Vector512<sbyte> left, Vector512<sbyte> right) => CompareNotEqual(left, right); 621public static Vector512<ushort> CompareEqual(Vector512<ushort> left, Vector512<ushort> right) => CompareEqual(left, right); 626public static Vector512<ushort> CompareGreaterThan(Vector512<ushort> left, Vector512<ushort> right) => CompareGreaterThan(left, right); 631public static Vector512<ushort> CompareGreaterThanOrEqual(Vector512<ushort> left, Vector512<ushort> right) => CompareGreaterThanOrEqual(left, right); 636public static Vector512<ushort> CompareLessThan(Vector512<ushort> left, Vector512<ushort> right) => CompareLessThan(left, right); 641public static Vector512<ushort> CompareLessThanOrEqual(Vector512<ushort> left, Vector512<ushort> right) => CompareLessThanOrEqual(left, right); 646public static Vector512<ushort> CompareNotEqual(Vector512<ushort> left, Vector512<ushort> right) => CompareNotEqual(left, right); 652public static Vector256<byte> ConvertToVector256Byte(Vector512<short> value) => ConvertToVector256Byte(value); 657public static Vector256<byte> ConvertToVector256Byte(Vector512<ushort> value) => ConvertToVector256Byte(value); 662public static Vector256<byte> ConvertToVector256ByteWithSaturation(Vector512<ushort> value) => ConvertToVector256ByteWithSaturation(value); 668public static Vector256<sbyte> ConvertToVector256SByte(Vector512<short> value) => ConvertToVector256SByte(value); 673public static Vector256<sbyte> ConvertToVector256SByte(Vector512<ushort> value) => ConvertToVector256SByte(value); 678public static Vector256<sbyte> ConvertToVector256SByteWithSaturation(Vector512<short> value) => ConvertToVector256SByteWithSaturation(value); 684public static Vector512<short> ConvertToVector512Int16(Vector256<sbyte> value) => ConvertToVector512Int16(value); 689public static Vector512<short> ConvertToVector512Int16(Vector256<byte> value) => ConvertToVector512Int16(value); 694public static Vector512<ushort> ConvertToVector512UInt16(Vector256<sbyte> value) => ConvertToVector512UInt16(value); 699public static Vector512<ushort> ConvertToVector512UInt16(Vector256<byte> value) => ConvertToVector512UInt16(value); 705public static new unsafe Vector512<sbyte> LoadVector512(sbyte* address) => LoadVector512(address); 710public static new unsafe Vector512<byte> LoadVector512(byte* address) => LoadVector512(address); 715public static new unsafe Vector512<short> LoadVector512(short* address) => LoadVector512(address); 720public static new unsafe Vector512<ushort> LoadVector512(ushort* address) => LoadVector512(address); 726public static Vector512<sbyte> Max(Vector512<sbyte> left, Vector512<sbyte> right) => Max(left, right); 731public static Vector512<byte> Max(Vector512<byte> left, Vector512<byte> right) => Max(left, right); 736public static Vector512<short> Max(Vector512<short> left, Vector512<short> right) => Max(left, right); 741public static Vector512<ushort> Max(Vector512<ushort> left, Vector512<ushort> right) => Max(left, right); 747public static Vector512<sbyte> Min(Vector512<sbyte> left, Vector512<sbyte> right) => Min(left, right); 752public static Vector512<byte> Min(Vector512<byte> left, Vector512<byte> right) => Min(left, right); 757public static Vector512<short> Min(Vector512<short> left, Vector512<short> right) => Min(left, right); 762public static Vector512<ushort> Min(Vector512<ushort> left, Vector512<ushort> right) => Min(left, right); 768public static Vector512<int> MultiplyAddAdjacent(Vector512<short> left, Vector512<short> right) => MultiplyAddAdjacent(left, right); 773public static Vector512<short> MultiplyAddAdjacent(Vector512<byte> left, Vector512<sbyte> right) => MultiplyAddAdjacent(left, right); 779public static Vector512<short> MultiplyHigh(Vector512<short> left, Vector512<short> right) => MultiplyHigh(left, right); 784public static Vector512<ushort> MultiplyHigh(Vector512<ushort> left, Vector512<ushort> right) => MultiplyHigh(left, right); 790public static Vector512<short> MultiplyHighRoundScale(Vector512<short> left, Vector512<short> right) => MultiplyHighRoundScale(left, right); 796public static Vector512<short> MultiplyLow(Vector512<short> left, Vector512<short> right) => MultiplyLow(left, right); 801public static Vector512<ushort> MultiplyLow(Vector512<ushort> left, Vector512<ushort> right) => MultiplyLow(left, right); 807public static Vector512<sbyte> PackSignedSaturate(Vector512<short> left, Vector512<short> right) => PackSignedSaturate(left, right); 812public static Vector512<short> PackSignedSaturate(Vector512<int> left, Vector512<int> right) => PackSignedSaturate(left, right); 818public static Vector512<byte> PackUnsignedSaturate(Vector512<short> left, Vector512<short> right) => PackUnsignedSaturate(left, right); 823public static Vector512<ushort> PackUnsignedSaturate(Vector512<int> left, Vector512<int> right) => PackUnsignedSaturate(left, right); 829public static Vector512<short> PermuteVar32x16(Vector512<short> left, Vector512<short> control) => PermuteVar32x16(left, control); 834public static Vector512<ushort> PermuteVar32x16(Vector512<ushort> left, Vector512<ushort> control) => PermuteVar32x16(left, control); 841public static Vector512<short> PermuteVar32x16x2(Vector512<short> lower, Vector512<short> indices, Vector512<short> upper) => PermuteVar32x16x2(lower, indices, upper); 847public static Vector512<ushort> PermuteVar32x16x2(Vector512<ushort> lower, Vector512<ushort> indices, Vector512<ushort> upper) => PermuteVar32x16x2(lower, indices, upper); 853public static Vector512<short> ShiftLeftLogical(Vector512<short> value, Vector128<short> count) => ShiftLeftLogical(value, count); 858public static Vector512<ushort> ShiftLeftLogical(Vector512<ushort> value, Vector128<ushort> count) => ShiftLeftLogical(value, count); 864public static Vector512<short> ShiftLeftLogical(Vector512<short> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); 869public static Vector512<ushort> ShiftLeftLogical(Vector512<ushort> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); 875public static Vector512<sbyte> ShiftLeftLogical128BitLane(Vector512<sbyte> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); 880public static Vector512<byte> ShiftLeftLogical128BitLane(Vector512<byte> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); 886public static Vector512<short> ShiftLeftLogicalVariable(Vector512<short> value, Vector512<ushort> count) => ShiftLeftLogicalVariable(value, count); 891public static Vector512<ushort> ShiftLeftLogicalVariable(Vector512<ushort> value, Vector512<ushort> count) => ShiftLeftLogicalVariable(value, count); 897public static Vector512<short> ShiftRightArithmetic(Vector512<short> value, Vector128<short> count) => ShiftRightArithmetic(value, count); 903public static Vector512<short> ShiftRightArithmetic(Vector512<short> value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); 909public static Vector512<short> ShiftRightArithmeticVariable(Vector512<short> value, Vector512<ushort> count) => ShiftRightArithmeticVariable(value, count); 915public static Vector512<short> ShiftRightLogical(Vector512<short> value, Vector128<short> count) => ShiftRightLogical(value, count); 920public static Vector512<ushort> ShiftRightLogical(Vector512<ushort> value, Vector128<ushort> count) => ShiftRightLogical(value, count); 926public static Vector512<short> ShiftRightLogical(Vector512<short> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); 931public static Vector512<ushort> ShiftRightLogical(Vector512<ushort> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); 937public static Vector512<sbyte> ShiftRightLogical128BitLane(Vector512<sbyte> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); 942public static Vector512<byte> ShiftRightLogical128BitLane(Vector512<byte> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); 948public static Vector512<short> ShiftRightLogicalVariable(Vector512<short> value, Vector512<ushort> count) => ShiftRightLogicalVariable(value, count); 953public static Vector512<ushort> ShiftRightLogicalVariable(Vector512<ushort> value, Vector512<ushort> count) => ShiftRightLogicalVariable(value, count); 959public static Vector512<sbyte> Shuffle(Vector512<sbyte> value, Vector512<sbyte> mask) => Shuffle(value, mask); 964public static Vector512<byte> Shuffle(Vector512<byte> value, Vector512<byte> mask) => Shuffle(value, mask); 970public static Vector512<short> ShuffleHigh(Vector512<short> value, [ConstantExpected] byte control) => ShuffleHigh(value, control); 975public static Vector512<ushort> ShuffleHigh(Vector512<ushort> value, [ConstantExpected] byte control) => ShuffleHigh(value, control); 981public static Vector512<short> ShuffleLow(Vector512<short> value, [ConstantExpected] byte control) => ShuffleLow(value, control); 986public static Vector512<ushort> ShuffleLow(Vector512<ushort> value, [ConstantExpected] byte control) => ShuffleLow(value, control); 992public static new unsafe void Store(sbyte* address, Vector512<sbyte> source) => Store(address, source); 997public static new unsafe void Store(byte* address, Vector512<byte> source) => Store(address, source); 1002public static new unsafe void Store(short* address, Vector512<short> source) => Store(address, source); 1007public static new unsafe void Store(ushort* address, Vector512<ushort> source) => Store(address, source); 1013public static Vector512<sbyte> Subtract(Vector512<sbyte> left, Vector512<sbyte> right) => Subtract(left, right); 1018public static Vector512<byte> Subtract(Vector512<byte> left, Vector512<byte> right) => Subtract(left, right); 1023public static Vector512<short> Subtract(Vector512<short> left, Vector512<short> right) => Subtract(left, right); 1028public static Vector512<ushort> Subtract(Vector512<ushort> left, Vector512<ushort> right) => Subtract(left, right); 1034public static Vector512<sbyte> SubtractSaturate(Vector512<sbyte> left, Vector512<sbyte> right) => SubtractSaturate(left, right); 1039public static Vector512<short> SubtractSaturate(Vector512<short> left, Vector512<short> right) => SubtractSaturate(left, right); 1044public static Vector512<byte> SubtractSaturate(Vector512<byte> left, Vector512<byte> right) => SubtractSaturate(left, right); 1049public static Vector512<ushort> SubtractSaturate(Vector512<ushort> left, Vector512<ushort> right) => SubtractSaturate(left, right); 1055public static Vector512<ushort> SumAbsoluteDifferences(Vector512<byte> left, Vector512<byte> right) => SumAbsoluteDifferences(left, right); 1061public static Vector512<ushort> SumAbsoluteDifferencesInBlock32(Vector512<byte> left, Vector512<byte> right, [ConstantExpected] byte control) => SumAbsoluteDifferencesInBlock32(left, right, control); 1067public static Vector512<sbyte> UnpackHigh(Vector512<sbyte> left, Vector512<sbyte> right) => UnpackHigh(left, right); 1072public static Vector512<byte> UnpackHigh(Vector512<byte> left, Vector512<byte> right) => UnpackHigh(left, right); 1077public static Vector512<short> UnpackHigh(Vector512<short> left, Vector512<short> right) => UnpackHigh(left, right); 1082public static Vector512<ushort> UnpackHigh(Vector512<ushort> left, Vector512<ushort> right) => UnpackHigh(left, right); 1088public static Vector512<sbyte> UnpackLow(Vector512<sbyte> left, Vector512<sbyte> right) => UnpackLow(left, right); 1093public static Vector512<byte> UnpackLow(Vector512<byte> left, Vector512<byte> right) => UnpackLow(left, right); 1098public static Vector512<short> UnpackLow(Vector512<short> left, Vector512<short> right) => UnpackLow(left, right); 1103public static Vector512<ushort> UnpackLow(Vector512<ushort> left, Vector512<ushort> right) => UnpackLow(left, right);