137if (Vector512.IsHardwareAccelerated) 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) 353Vector512<int> result = Vector512.LoadUnsafe(ref left, i) & Vector512.LoadUnsafe(ref right, i); 422if (Vector512.IsHardwareAccelerated && (uint)count >= Vector512<int>.Count) 426Vector512<int> result = Vector512.LoadUnsafe(ref left, i) | Vector512.LoadUnsafe(ref right, i); 496if (Vector512.IsHardwareAccelerated && (uint)count >= Vector512<int>.Count) 500Vector512<int> result = Vector512.LoadUnsafe(ref left, i) ^ Vector512.LoadUnsafe(ref right, i); 561if (Vector512.IsHardwareAccelerated && (uint)count >= Vector512<int>.Count) 565Vector512<int> result = ~Vector512.LoadUnsafe(ref value, i); 845Vector512<byte> shuffleMask = Vector512.Create(lowerShuffleMask_CopyToBoolArray256, upperShuffleMask_CopyToBoolArray256); 846Vector512<byte> bitMask = Vector512.Create(0x80402010_08040201).AsByte(); 847Vector512<byte> ones = Vector512.Create((byte)1); 854Vector512<ulong> scalar = Vector512.Create(bits);

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

75else if (!Vector512.IsHardwareAccelerated || !Vector512<T>.IsSupported || span.Length < Vector512<T>.Count) 104Vector512<T> best = Vector512.LoadUnsafe(ref current); 109best = TMinMax.Compare(best, Vector512.LoadUnsafe(ref current)); 112best = TMinMax.Compare(best, Vector512.LoadUnsafe(ref lastVectorStart));

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

72if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TTransformOperator.Vectorizable) 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)); 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))); 619beg = Vector512.ConditionalSelect(CreateAlignmentMaskVector512<T>((int)misalignment), beg, Vector512.Create(TAggregationOperator.IdentityValue)); 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))); 686end = Vector512.ConditionalSelect(CreateRemainderMaskVector512<T>((int)trailing), end, Vector512.Create(TAggregationOperator.IdentityValue)); 1191if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TBinaryOperator.Vectorizable) 1686Vector512<T> vresult = Vector512.Create(TAggregationOperator.IdentityValue); 1690Vector512<T> beg = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef), 1691Vector512.LoadUnsafe(ref yRef)); 1692Vector512<T> end = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count), 1693Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count)); 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))); 1808beg = Vector512.ConditionalSelect(CreateAlignmentMaskVector512<T>((int)misalignment), beg, Vector512.Create(TAggregationOperator.IdentityValue)); 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))); 1882end = Vector512.ConditionalSelect(CreateRemainderMaskVector512<T>((int)trailing), end, Vector512.Create(TAggregationOperator.IdentityValue)); 2467return Vector512.LoadUnsafe( 2474return Vector512.LoadUnsafe( 2481return Vector512.LoadUnsafe( 2488return Vector512.LoadUnsafe( 2575return Vector512.LoadUnsafe( 2582return Vector512.LoadUnsafe( 2589return Vector512.LoadUnsafe( 2596return Vector512.LoadUnsafe(

85if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TBinaryOperator.Vectorizable) 644Vector512<T> beg = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef), 645Vector512.LoadUnsafe(ref yRef)); 646Vector512<T> end = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count), 647Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count)); 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))); 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))); 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))); 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))); 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))); 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))); 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))); 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))); 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))); 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))); 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))); 1417if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TTransformOperator.Vectorizable && TBinaryOperator.Vectorizable) 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)), 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))), 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))), 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))), 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))), 2130Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8))), 2138Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7))), 2146Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6))), 2154Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5))), 2162Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4))), 2170Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3))), 2178Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2))),

43public static bool ShouldEarlyExit(Vector512<T> result) => Vector512.AnyWhereAllBitsSet(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) 109if (TAnyAll.ShouldEarlyExit(TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i)))) 120TAnyAll.ShouldEarlyExit(TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count))))) 235if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 259Vector512<byte> v = TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i)).AsByte(); 343if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 368Vector512.Narrow( 369TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i)).AsUInt16(), 370TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<T>.Count))).AsUInt16()); 460if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 485Vector512.Narrow( 486Vector512.Narrow( 487TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i)).AsUInt32(), 488TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<T>.Count))).AsUInt32()), 489Vector512.Narrow( 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())); 587if (Vector512.IsHardwareAccelerated && TOperator.Vectorizable && Vector512<T>.IsSupported) 614Vector512.Narrow( 615Vector512.Narrow( 616Vector512.Narrow( 617TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i)).AsUInt64(), 618TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<T>.Count))).AsUInt64()), 619Vector512.Narrow( 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())), 622Vector512.Narrow( 623Vector512.Narrow( 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()), 626Vector512.Narrow( 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())));

51if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TStatefulUnaryOperator.Vectorizable) 547Vector512<T> beg = op.Invoke(Vector512.LoadUnsafe(ref xRef)); 548Vector512<T> end = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count)); 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))); 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))); 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))); 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))); 689Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8))); 696Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7))); 703Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6))); 710Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5))); 717Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4))); 724Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3))); 731Vector512<T> vector = op.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)));

70if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported) 692Vector512<T> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef), 693Vector512.LoadUnsafe(ref yRef), 694Vector512.LoadUnsafe(ref zRef)); 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)); 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))); 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))); 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))); 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))); 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))); 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))); 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))); 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))); 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))); 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))); 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))); 1545if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported) 2159Vector512<T> zVec = Vector512.Create(z); 2161Vector512<T> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef), 2162Vector512.LoadUnsafe(ref yRef), 2164Vector512<T> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count), 2165Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count), 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)), 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)), 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)), 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)), 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)), 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)), 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)), 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)), 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)), 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)), 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)), 3031if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported) 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), 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)), 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)), 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)), 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)), 3816Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)), 3825Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)), 3834Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)), 3843Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)), 3852Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)), 3861Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)), 3870Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)),

71if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TUnaryOperator.Vectorizable) 79(Vector512<T> first, Vector512<T> second) = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i)); 92(Vector512<T> first, Vector512<T> second) = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i)); 206if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TOperator.Vectorizable) 214(Vector512<T> first, Vector512<T> second) = TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i), Vector512.LoadUnsafe(ref yRef, (uint)i)); 225Vector512<T> mask = Vector512.Equals(CreateRemainderMaskVector512<T>(x.Length - i), Vector512<T>.Zero); 229Vector512<T> first = Vector512.ConditionalSelect(mask, 230Vector512.Create(TOperator.RemainderMaskValue), 231Vector512.LoadUnsafe(ref xRef, (uint)i)); 233Vector512<T> second = Vector512.ConditionalSelect(mask, 234Vector512.Create(TOperator.RemainderMaskValue), 235Vector512.LoadUnsafe(ref yRef, (uint)i)); 239Vector512.ConditionalSelect(mask, 240Vector512.LoadUnsafe(ref destination1Ref, (uint)i), 244Vector512.ConditionalSelect(mask, 245Vector512.LoadUnsafe(ref destination2Ref, (uint)i), 387if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TOperator.Vectorizable) 392Vector512<T> yVec = Vector512.Create(y); 397(Vector512<T> first, Vector512<T> second) = TOperator.Invoke(Vector512.LoadUnsafe(ref xRef, (uint)i), yVec); 408Vector512<T> mask = Vector512.Equals(CreateRemainderMaskVector512<T>(x.Length - i), Vector512<T>.Zero); 412Vector512<T> first = Vector512.ConditionalSelect(mask, 413Vector512.Create(TOperator.RemainderMaskValue), 414Vector512.LoadUnsafe(ref xRef, (uint)i)); 416Vector512<T> second = Vector512.ConditionalSelect(mask, 417Vector512.Create(TOperator.RemainderMaskValue), 422Vector512.ConditionalSelect(mask, 423Vector512.LoadUnsafe(ref destination1Ref, (uint)i), 427Vector512.ConditionalSelect(mask, 428Vector512.LoadUnsafe(ref destination2Ref, (uint)i),

44if (Vector512.IsHardwareAccelerated && TUnaryOperator.Vectorizable) 55(Vector512<TOutput>, Vector512<TOutput>, Vector512<TOutput>, Vector512<TOutput>) results = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i)); 70(Vector512<TOutput>, Vector512<TOutput>, Vector512<TOutput>, Vector512<TOutput>) results = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i));

44if (Vector512.IsHardwareAccelerated && TUnaryOperator.Vectorizable) 55(Vector512<TOutput> lower, Vector512<TOutput> upper) = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i)); 68(Vector512<TOutput> lower, Vector512<TOutput> upper) = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i));

91if (Vector512.IsHardwareAccelerated && Vector512<TInput>.IsSupported && Vector512<TOutput>.IsSupported && TUnaryOperator.Vectorizable && sizeof(TInput) == sizeof(TOutput)) 587Vector512<TOutput> beg = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef)); 588Vector512<TOutput> end = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<TInput>.Count)); 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))); 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))); 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))); 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))); 729Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 8))); 736Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 7))); 743Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 6))); 750Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 5))); 757Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 4))); 764Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 3))); 771Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 2)));

44if (Vector512.IsHardwareAccelerated && TUnaryOperator.Vectorizable) 56Vector512.LoadUnsafe(ref xRef, (uint)i), 57Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i); 69Vector512.LoadUnsafe(ref xRef, (uint)i), 70Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i);

96Vector512<T> abs = Vector512.ConditionalSelect(Vector512.LessThan(x, Vector512<T>.Zero), -x, x); 97if (Vector512.LessThan(abs, Vector512<T>.Zero) != Vector512<T>.Zero) 103return Vector512.Abs(x);

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

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

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

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) => AtanOperator<T>.Invoke(x) / Vector512.Create(T.Pi);

63return ExpOperator<float>.Invoke(LogOperator<float>.Invoke(x.AsSingle()) / Vector512.Create(3f)).As<float, T>(); 68return ExpOperator<double>.Invoke(LogOperator<double>.Invoke(x.AsDouble()) / Vector512.Create(3d)).As<double, T>();

61return Vector512.Ceiling(x.AsSingle()).As<float, T>(); 66return Vector512.Ceiling(x.AsDouble()).As<double, T>();

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

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); 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); 312Vector512.ConvertToSingle(results.Item1), 313Vector512.ConvertToSingle(results.Item2), 314Vector512.ConvertToSingle(results.Item3), 315Vector512.ConvertToSingle(results.Item4) 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); 500(Vector512<int> lowerInt32, Vector512<int> upperInt32) = Vector512.Widen(x); 508Vector512<uint> sign = value & Vector512.Create(SingleSignMask); 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; 529bitValueInProcess = Vector512.ShiftLeft(bitValueInProcess, 13); 532offsetMaskedExponentLowerBound = Vector512.ConditionalSelect(Vector512.Equals(infinityOrNaNMask, Vector512<uint>.Zero), 534Vector512.ShiftLeft(offsetMaskedExponentLowerBound, 1)); 537bitValueInProcess &= Vector512.Create(HalfToSingleBitsMask); 705return Vector512.Narrow( 714Vector512<uint> sign = Vector512.ShiftRightLogical(bitValue & Vector512.Create(SingleSignMask), 16); 717Vector512<uint> realMask = Vector512.Equals(value, value).AsUInt32(); 720value = Vector512.Abs(value); 723value = Vector512.Min(Vector512.Create(MaxHalfValueBelowInfinity), value); 726Vector512<uint> exponentOffset0 = Vector512.Max(value, Vector512.Create(MinExp).AsSingle()).AsUInt32(); 729exponentOffset0 &= Vector512.Create(SingleBiasedExponentMask); 732exponentOffset0 += Vector512.Create(Exponent13); 739Vector512<uint> maskedHalfExponentForNaN = ~realMask & Vector512.Create(ExponentMask); 742bitValue -= Vector512.Create(Exponent126); 745Vector512<uint> newExponent = Vector512.ShiftRightLogical(bitValue, 13);

78if (typeof(TTo) == typeof(int)) return Vector512.ConvertToInt32(x.AsSingle()).As<int, TTo>(); 79if (typeof(TTo) == typeof(uint)) return Vector512.ConvertToUInt32(x.AsSingle()).As<uint, TTo>(); 84if (typeof(TTo) == typeof(long)) return Vector512.ConvertToInt64(x.AsDouble()).As<long, TTo>(); 85if (typeof(TTo) == typeof(ulong)) return Vector512.ConvertToUInt64(x.AsDouble()).As<ulong, TTo>();

78if (typeof(TTo) == typeof(int)) return Vector512.ConvertToInt32Native(x.AsSingle()).As<int, TTo>(); 79if (typeof(TTo) == typeof(uint)) return Vector512.ConvertToUInt32Native(x.AsSingle()).As<uint, TTo>(); 84if (typeof(TTo) == typeof(long)) return Vector512.ConvertToInt64Native(x.AsDouble()).As<long, TTo>(); 85if (typeof(TTo) == typeof(ulong)) return Vector512.ConvertToUInt64Native(x.AsDouble()).As<ulong, TTo>();

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

115return Vector512.CopySign(x, y);

123return Vector512.Cos(x.AsDouble()).As<double, T>(); 128return Vector512.Cos(x.AsSingle()).As<float, T>();

121Vector512<float> y = Vector512.Abs(x); 122Vector512<float> z = ExpOperator<float>.Invoke(y - Vector512.Create((float)Single_LOGV)); 123return (Vector512.Create((float)Single_HALFV) * (z + (Vector512.Create((float)Single_INVV2) / z))).As<float, T>(); 130Vector512<double> y = Vector512.Abs(x); 131Vector512<double> z = ExpOperator<double>.Invoke(y - Vector512.Create(Double_LOGV)); 132return (Vector512.Create(Double_HALFV) * (z + (Vector512.Create(Double_INVV2) / z))).As<double, T>();

52if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 66Vector512<T> xVec = Vector512.LoadUnsafe(ref xRef, (uint)i); 67Vector512<T> yVec = Vector512.LoadUnsafe(ref yRef, (uint)i); 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)); 94Vector512.Sum(dotProductVector) / 95(T.Sqrt(Vector512.Sum(xSumOfSquaresVector)) * T.Sqrt(Vector512.Sum(ySumOfSquaresVector)));

89Vector512<T> xpi = x * Vector512.Create(T.Pi); 93if (Vector512.GreaterThanAny(xpi.AsUInt32() & Vector512.Create(CosOperatorSingle.SignMask), Vector512.Create(CosOperatorSingle.MaxVectorizedValue))) 101if (Vector512.GreaterThanAny(xpi.AsUInt64() & Vector512.Create(CosOperatorDouble.SignMask), Vector512.Create(CosOperatorDouble.MaxVectorizedValue)))

71return Vector512.DegreesToRadians(x.AsDouble()).As<double, T>(); 76return Vector512.DegreesToRadians(x.AsSingle()).As<float, T>();

97return Vector512.Exp(x.AsDouble()).As<double, T>(); 102return Vector512.Exp(x.AsSingle()).As<float, T>();

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

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

17Vector512.Create(ApplyScalar<TOperator>(floats.GetLower()), ApplyScalar<TOperator>(floats.GetUpper())); 26Vector512.Create(ApplyScalar<TOperator>(doubles.GetLower()), ApplyScalar<TOperator>(doubles.GetUpper())); 61Vector512.Create(firstLower, firstUpper), 62Vector512.Create(secondLower, secondUpper) 97Vector512.Create(firstLower, firstUpper), 98Vector512.Create(secondLower, secondUpper)

61return Vector512.Floor(x.AsSingle()).As<float, T>(); 66return Vector512.Floor(x.AsDouble()).As<double, T>();

184return Vector512.FusedMultiplyAdd(x.AsDouble(), y.AsDouble(), z.AsDouble()).As<double, T>(); 189return Vector512.FusedMultiplyAdd(x.AsSingle(), y.AsSingle(), z.AsSingle()).As<float, T>();

79if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 88Vector512<T> xVec = Vector512.LoadUnsafe(ref xRef, (uint)i); 89Vector512<T> yVec = Vector512.LoadUnsafe(ref yRef, (uint)i); 91count += BitOperations.PopCount((~Vector512.Equals(xVec, yVec)).ExtractMostSignificantBits()); 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)); 107count += BitOperations.PopCount((~Vector512.Equals(xVec, yVec)).ExtractMostSignificantBits());

75return Vector512.Hypot(x.AsDouble(), y.AsDouble()).As<double, T>(); 80return Vector512.Hypot(x.AsSingle(), y.AsSingle()).As<float, T>();

89Vector512<T> useResult = Vector512.GreaterThan(result, current); 90Vector512<T> equalMask = Vector512.Equals(result, 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) 154sizeof(T) == sizeof(long) ? Vector512.Create((long)i).As<long, T>() : 155sizeof(T) == sizeof(int) ? Vector512.Create(i).As<int, T>() : 156sizeof(T) == sizeof(short) ? Vector512.Create((short)i).As<short, T>() : 157Vector512.Create((byte)i).As<byte, T>(); 177Vector512<T> result = Vector512.LoadUnsafe(ref xRef); 183nanMask = ~Vector512.Equals(result, result); 197current = Vector512.LoadUnsafe(ref xRef, (uint)i); 202nanMask = ~Vector512.Equals(current, current); 217current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 222nanMask = ~Vector512.Equals(current, current); 461sizeof(T) == sizeof(long) ? Vector512.LessThan(indices1.AsInt64(), indices2.AsInt64()).As<long, T>() : 462sizeof(T) == sizeof(int) ? Vector512.LessThan(indices1.AsInt32(), indices2.AsInt32()).As<int, T>() : 463sizeof(T) == sizeof(short) ? Vector512.LessThan(indices1.AsInt16(), indices2.AsInt16()).As<short, T>() : 464Vector512.LessThan(indices1.AsByte(), indices2.AsByte()).As<byte, T>(); 515return Vector512.ConditionalSelect(mask, left, right);

88Vector512<T> resultMag = Vector512.Abs(result), currentMag = Vector512.Abs(current); 89Vector512<T> useResult = Vector512.GreaterThan(resultMag, currentMag); 90Vector512<T> equalMask = Vector512.Equals(resultMag, currentMag); 99Vector512<T> sameSign = Vector512.Equals(IsNegative(result).AsInt32(), currentNegative.AsInt32()).As<int, T>();

86Vector512<T> useResult = Vector512.LessThan(result, current); 87Vector512<T> equalMask = Vector512.Equals(result, current); 96Vector512<T> sameSign = Vector512.Equals(resultNegative.AsInt32(), IsNegative(current).AsInt32()).As<int, T>();

88Vector512<T> resultMag = Vector512.Abs(result), currentMag = Vector512.Abs(current); 89Vector512<T> useResult = Vector512.LessThan(resultMag, currentMag); 90Vector512<T> equalMask = Vector512.Equals(resultMag, currentMag); 99Vector512<T> sameSign = Vector512.Equals(resultNegative.AsInt32(), IsNegative(current).AsInt32()).As<int, T>();

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

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

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

74public static Vector512<T> Invoke(Vector512<T> x) => Vector512.IsInteger(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);

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

66Vector512.Equals(x & (x - Vector512<T>.One), Vector512<T>.Zero) & 67Vector512.GreaterThan(x, Vector512<T>.Zero);

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

145Vector512.Create((byte)8, 7, 6, 6, 5, 5, 5, 5, 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); 182return Vector512.Create(Invoke(x.GetLower()), Invoke(x.GetUpper()));

119return Vector512.Lerp(x.AsDouble(), y.AsDouble(), amount.AsDouble()).As<double, T>(); 124return Vector512.Lerp(x.AsSingle(), y.AsSingle(), amount.AsSingle()).As<float, T>();

139return Vector512.Log(x.AsDouble()).As<double, T>(); 144return Vector512.Log(x.AsSingle()).As<float, T>();

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

99return Vector512.Log2(x.AsDouble()).As<double, T>(); 104return Vector512.Log2(x.AsSingle()).As<float, T>();

137return Vector512.Max(x, y); 180return Vector512.IsNaN(vector); 255return Vector512.IsNegative(vector); 345return Vector512.IsPositive(vector); 388if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count) 394Vector512<T> result = Vector512.LoadUnsafe(ref xRef, 0); 415current = Vector512.LoadUnsafe(ref xRef, (uint)i); 420nanMask = ~Vector512.Equals(current, current); 434current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count)); 439nanMask = ~Vector512.Equals(current, current);

121return Vector512.MaxMagnitude(x, y);

178return Vector512.MaxMagnitudeNumber(x, y);

128return Vector512.MaxNumber(x, y);

135return Vector512.Min(x, y);

133return Vector512.MinMagnitude(x, y);

176return Vector512.MinMagnitudeNumber(x, y);

128return Vector512.MinNumber(x, y);

185return Vector512.MultiplyAddEstimate(x.AsDouble(), y.AsDouble(), z.AsDouble()).As<double, T>(); 189return Vector512.MultiplyAddEstimate(x.AsSingle(), y.AsSingle(), z.AsSingle()).As<float, T>();

188Vector512<byte> c1 = Vector512.Create((byte)0x55); 189Vector512<byte> c2 = Vector512.Create((byte)0x33); 190Vector512<byte> c3 = Vector512.Create((byte)0x0F); 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); 218Vector512<uint> c1 = Vector512.Create(0x55555555u); 219Vector512<uint> c2 = Vector512.Create(0x33333333u); 220Vector512<uint> c3 = Vector512.Create(0x0F0F0F0Fu); 221Vector512<uint> c4 = Vector512.Create(0x01010101u);

71return Vector512.RadiansToDegrees(x.AsDouble()).As<double, T>(); 76return Vector512.RadiansToDegrees(x.AsSingle()).As<float, T>();

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

65return ExpOperator<float>.Invoke(LogOperator<float>.Invoke(x.AsSingle()) / Vector512.Create((float)_n)).As<float, T>(); 70return ExpOperator<double>.Invoke(LogOperator<double>.Invoke(x.AsDouble()) / Vector512.Create((double)_n)).As<double, T>();

222return Vector512.Round(x.AsDouble()).As<double, T>(); 227return Vector512.Round(x.AsSingle()).As<float, T>(); 284return TruncateOperator<float>.Invoke(x.AsSingle() + CopySignOperator<float>.Invoke(Vector512.Create(0.49999997f), x.AsSingle())).As<float, T>(); 289return TruncateOperator<double>.Invoke(x.AsDouble() + CopySignOperator<double>.Invoke(Vector512.Create(0.49999999999999994), x.AsDouble())).As<double, T>(); 338Vector512<T> limit = Vector512.Create(typeof(T) == typeof(float) ? T.CreateTruncating(Single_RoundLimit) : T.CreateTruncating(Double_RoundLimit)); 339return Vector512.ConditionalSelect(Vector512.LessThan(Vector512.Abs(x), limit),

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

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

95return Vector512.ConditionalSelect(Vector512.Equals(x, Vector512<T>.Zero).AsInt32(), 106if (Vector512.EqualsAny(IsNaN(x).AsInt32(), Vector512<int>.AllBitsSet)) 111return Vector512.ConditionalSelect(Vector512.LessThan(x, Vector512<T>.Zero).AsInt32(), 112Vector512.Create(-1), 113Vector512.ConditionalSelect(Vector512.GreaterThan(x, Vector512<T>.Zero).AsInt32(),

113return Vector512.Sin(x.AsDouble()).As<double, T>(); 118return Vector512.Sin(x.AsSingle()).As<float, T>();

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

89Vector512<T> xpi = x * Vector512.Create(T.Pi); 93if (Vector512.GreaterThanAny(xpi.AsUInt32() & Vector512.Create(SinOperatorSingle.SignMask), Vector512.Create(SinOperatorSingle.MaxVectorizedValue))) 101if (Vector512.GreaterThanAny(xpi.AsUInt64() & Vector512.Create(SinOperatorDouble.SignMask), Vector512.Create(SinOperatorDouble.MaxVectorizedValue)))

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

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

193Vector512<float> uxMasked = Vector512.Abs(x); 194if (Vector512.GreaterThanAny(uxMasked.AsUInt32(), Vector512.Create(MaxVectorizedValue))) 199Vector512<float> dn = MultiplyAddEstimateOperator<float>.Invoke(uxMasked, Vector512.Create(2 / float.Pi), Vector512.Create(AlmHuge)); 201dn -= Vector512.Create(AlmHuge); 204f = MultiplyAddEstimateOperator<float>.Invoke(dn, Vector512.Create(-float.Pi / 2), f); 205f = MultiplyAddEstimateOperator<float>.Invoke(dn, Vector512.Create(Pi_Tail2), f); 206f = MultiplyAddEstimateOperator<float>.Invoke(dn, Vector512.Create(Pi_Tail3), f); 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)); 217Vector512<float> b2 = MultiplyAddEstimateOperator<float>.Invoke(f8, a3, f12 * Vector512.Create(C7)); 220Vector512<float> result = (poly.AsUInt32() ^ (x.AsUInt32() & Vector512.Create(~SignMask))).AsSingle(); 221return Vector512.ConditionalSelect(Vector512.Equals(odd, Vector512<uint>.Zero).AsSingle(), 223Vector512.Create(-1f) / result); 350Vector512<double> uxMasked = Vector512.Abs(x); 351if (Vector512.GreaterThanAny(uxMasked.AsUInt64(), Vector512.Create(MaxVectorizedValue))) 357Vector512<double> dn = MultiplyAddEstimateOperator<double>.Invoke(uxMasked, Vector512.Create(2 / double.Pi), Vector512.Create(AlmHuge)); 359dn -= Vector512.Create(AlmHuge); 363f = MultiplyAddEstimateOperator<double>.Invoke(dn, Vector512.Create(-double.Pi / 2), f); 364f = MultiplyAddEstimateOperator<double>.Invoke(dn, Vector512.Create(-HalfPi2), f); 365f = MultiplyAddEstimateOperator<double>.Invoke(dn, Vector512.Create(-HalfPi3), f); 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)); 389Vector512<double> result = (poly.AsUInt64() ^ (x.AsUInt64() & Vector512.Create(~SignMask))).AsDouble(); 390return Vector512.ConditionalSelect(Vector512.Equals(odd, Vector512<ulong>.Zero).AsDouble(), 392Vector512.Create(-1.0) / result);

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); 116return (sign ^ (-z / (z + Vector512.Create(2f))).AsUInt32()).As<uint, T>(); 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); 125return (sign ^ (-z / (z + Vector512.Create(2d))).AsUInt64()).As<ulong, T>();

67return Vector512.Create(Invoke(x.GetLower()), Invoke(x.GetUpper()));

108return Vector512.Truncate(x.AsDouble()).As<double, T>(); 113return Vector512.Truncate(x.AsSingle()).As<float, T>();

53if (Vector512.IsHardwareAccelerated && Avx512Vbmi.IsSupported && (end >= src)) 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(); 1350str = Vector512.Load(src).AsSByte();

44if (Vector512.IsHardwareAccelerated && Avx512Vbmi.IsSupported && (end >= src)) 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(); 190str = Vector512.ConditionalSelect(maskBB, temp3.AsUInt32(), temp2.AsUInt32()).AsSByte(); 204str = Vector512.Load(src).AsSByte();

666Vector512<ushort> utf16VectorLower = Vector512.Load(src); 667Vector512<ushort> utf16VectorUpper = Vector512.Load(src + 32);

385(Vector512<ushort> utf16LowVector, Vector512<ushort> utf16HighVector) = Vector512.Widen(str);

166if (Vector512.IsHardwareAccelerated && length >= Vector512<ushort>.Count)

384return Vector512.ConvertToDouble(value.AsVector512()).AsVector(); 407return Vector512.ConvertToDouble(value.AsVector512()).AsVector(); 515return Vector512.ConvertToSingle(value.AsVector512()).AsVector(); 682return Vector512.Count(vector.AsVector512(), value); 1339return Vector512.IndexOf(vector.AsVector512(), value); 1585return Vector512.LastIndexOf(vector.AsVector512(), value); 2677return Vector512.ShiftLeft(vector.AsVector512(), shiftCount.AsVector512()).AsVector(); 2703return Vector512.ShiftLeft(vector.AsVector512(), shiftCount.AsVector512()).AsVector();

753if (Vector512.IsHardwareAccelerated) 1658if (Vector512.IsHardwareAccelerated) 1910if (Vector512.IsHardwareAccelerated) 3672if (Vector512.IsHardwareAccelerated) 3716if (Vector512.IsHardwareAccelerated)

30[StructLayout(LayoutKind.Sequential, Size = Vector512.Size)] 41get => Vector512.Create(Scalar<T>.AllBitsSet); 52return Vector512.Size / sizeof(T); 104get => Vector512.Create(Scalar<T>.One); 137return Vector512.Create( 152return Vector512.Create( 167return Vector512.Create( 182return Vector512.Create( 196return Vector512.Create( 224return Vector512.Create( 246return Vector512.Create( 261return Vector512.Create( 276return Vector512.Create( 298return Vector512.Create( 312return Vector512.Create( 327return Vector512.Create( 343return vector ^ Vector512.Create(-0.0f).As<float, T>(); 347return vector ^ Vector512.Create(-0.0).As<double, T>(); 374return Vector512.Create( 395if (Vector512.IsHardwareAccelerated) 399Vector512<T> result = Vector512.Equals(this, other) | ~(Vector512.Equals(this, this) | Vector512.Equals(other, other)); 461static int ISimdVector<Vector512<T>, T>.Alignment => Vector512.Alignment; 470get => Vector512.IsHardwareAccelerated; 475static Vector512<T> ISimdVector<Vector512<T>, T>.Abs(Vector512<T> vector) => Vector512.Abs(vector); 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); 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); 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); 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); 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); 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); 784static Vector512<T> ISimdVector<Vector512<T>, T>.MultiplyAddEstimate(Vector512<T> left, Vector512<T> right, Vector512<T> addend) => Vector512.MultiplyAddEstimate(left, right, addend); 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); 804static Vector512<T> ISimdVector<Vector512<T>, T>.Round(Vector512<T> vector) => Vector512.Round(vector); 820static Vector512<T> ISimdVector<Vector512<T>, T>.Sqrt(Vector512<T> vector) => Vector512.Sqrt(vector); 848static T ISimdVector<Vector512<T>, T>.Sum(Vector512<T> vector) => Vector512.Sum(vector); 856static Vector512<T> ISimdVector<Vector512<T>, T>.Truncate(Vector512<T> vector) => Vector512.Truncate(vector);

2378result = (TVectorDouble)(object)Vector512.ConvertToDouble((Vector512<long>)(object)vector); 2413result = (TVectorSingle)(object)Vector512.ConvertToSingle((Vector512<int>)(object)vector); 2537result = (TVector)(object)Vector512.Create(value); 2571result = (TVector)(object)Vector512.Create(value); 2668result = (TVectorSingle)(object)Vector512.Narrow((Vector512<double>)(object)lower, (Vector512<double>)(object)upper); 2714result = (TVectorUInt32)(object)Vector512.ShiftLeft( 2763result = (TVectorUInt64)(object)Vector512.ShiftLeft( 2952result = (TVectorDouble)(object)Vector512.Create(lower, upper); 2993result = (TVectorDouble)(object)Vector512.WidenLower((Vector512<float>)(object)vector); 3033result = (TVectorDouble)(object)Vector512.WidenUpper((Vector512<float>)(object)vector);

110Vector512<ushort> source0 = Vector512.LoadUnsafe(ref searchSpace0); 111Vector512<ushort> source1 = Vector512.LoadUnsafe(ref searchSpace1); 113Vector512<byte> sourceLower = Avx512Vbmi.PermuteVar64x8x2(source0.AsByte(), Vector512.CreateSequence<byte>(0, 2), source1.AsByte()); 114Vector512<byte> sourceUpper = Avx512Vbmi.PermuteVar64x8x2(source0.AsByte(), Vector512.CreateSequence<byte>(1, 2), source1.AsByte()); 132Vector512<byte> bitPositions = Avx512Vbmi.PermuteVar64x8(Vector512.Create(0x8040201008040201).AsByte(), shifted); 138return Vector512.Equals(bitMask & bitPositions, Vector512<byte>.Zero); 391return Vector512.IsHardwareAccelerated && Avx512Vbmi.VL.IsSupported 405return Vector512.IsHardwareAccelerated && Avx512Vbmi.VL.IsSupported 426Vector512<byte> charMap512 = Vector512.Create(charMap256); 601Vector512<byte> charMap512 = Vector512.Create(charMap256);

157if (Vector512.IsHardwareAccelerated && Avx512Vbmi.IsSupported && span.Length >= CharsPerIterationAvx512 + MatchStartOffsetN2) 177if (Vector512.IsHardwareAccelerated && Avx512Vbmi.IsSupported && span.Length >= CharsPerIterationAvx512 + MatchStartOffsetN3) 632ulong resultMask = (~Vector512.Equals(result, Vector512<byte>.Zero)).ExtractMostSignificantBits();

297public static Vector512<byte> TransformInput(Vector512<byte> input) => input & Vector512.Create(unchecked((byte)~0x20)); 365Vector512<byte> subtraction = Vector512.Create((byte)(128 + 'a')); 366Vector512<byte> comparison = Vector512.Create((byte)(128 + 26)); 367Vector512<byte> caseConversion = Vector512.Create((byte)0x20); 369Vector512<byte> matches = Vector512.LessThan((input - subtraction).AsSByte(), comparison.AsSByte()).AsByte();

38return (Vector512.Create(low), Vector512.Create(high)); 72return (Vector512.Create(low), Vector512.Create(high));

256Vector512<ushort> source0 = Vector512.LoadUnsafe(ref source); 257Vector512<ushort> source1 = Vector512.LoadUnsafe(ref source, (nuint)Vector512<ushort>.Count); 426return Avx512Vbmi.PermuteVar64x8x2(left, Vector512.CreateSequence<byte>(63, 1), right); 439return Avx512Vbmi.PermuteVar64x8x2(left, Vector512.CreateSequence<byte>(62, 1), right);

91if (Vector512.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector512<ushort>.Count >= 0) 93Vector512<ushort> ch1 = Vector512.Create(_ch1); 94Vector512<ushort> ch2 = Vector512.Create(_ch2); 95Vector512<ushort> ch3 = Vector512.Create(_ch3); 310Vector512<ushort> cmpCh1 = Vector512.Equals(ch1, Vector512.LoadUnsafe(ref searchSpace)); 311Vector512<ushort> cmpCh2 = Vector512.Equals(ch2, Vector512.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch2ByteOffset).AsUInt16()); 312Vector512<ushort> cmpCh3 = Vector512.Equals(ch3, Vector512.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch3ByteOffset).AsUInt16()); 317Vector512<ushort> caseConversion = Vector512.Create(CaseConversionMask); 319Vector512<ushort> cmpCh1 = Vector512.Equals(ch1, Vector512.LoadUnsafe(ref searchSpace) & caseConversion); 320Vector512<ushort> cmpCh2 = Vector512.Equals(ch2, Vector512.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch2ByteOffset).AsUInt16() & caseConversion); 321Vector512<ushort> cmpCh3 = Vector512.Equals(ch3, Vector512.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch3ByteOffset).AsUInt16() & caseConversion);

66if (Vector512.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector512<byte>.Count >= 0) 75Vector512<byte> ch1 = Vector512.Create(value); 76Vector512<byte> ch2 = Vector512.Create(ch2Val); 87Vector512<byte> cmpCh2 = Vector512.Equals(ch2, Vector512.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance))); 88Vector512<byte> cmpCh1 = Vector512.Equals(ch1, Vector512.LoadUnsafe(ref searchSpace, (nuint)offset)); 299if (Vector512.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector512<byte>.Count) 310Vector512<byte> ch1 = Vector512.Create(value); 311Vector512<byte> ch2 = Vector512.Create(ch2Val); 314Vector512<byte> cmpCh1 = Vector512.Equals(ch1, Vector512.LoadUnsafe(ref searchSpace, (nuint)offset)); 315Vector512<byte> cmpCh2 = Vector512.Equals(ch2, Vector512.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance))); 520if (Vector512.IsHardwareAccelerated) 572Vector512<byte> search = Vector512.Load(searchSpace + offset); 573ulong matches = Vector512.Equals(Vector512<byte>.Zero, search).ExtractMostSignificantBits(); 823if (Vector512.IsHardwareAccelerated && length >= (nuint)Vector512<byte>.Count) 833if (Vector512.LoadUnsafe(ref first, offset) != 834Vector512.LoadUnsafe(ref second, offset)) 843if (Vector512.LoadUnsafe(ref first, lengthToExamine) == 844Vector512.LoadUnsafe(ref second, lengthToExamine)) 978if (Vector512.IsHardwareAccelerated && (lengthToExamine >= (nuint)Vector512<byte>.Count)) 984matches = Vector512.Equals(Vector512.LoadUnsafe(ref first, offset), Vector512.LoadUnsafe(ref second, offset)).ExtractMostSignificantBits(); 1001matches = Vector512.Equals(Vector512.LoadUnsafe(ref first, offset), Vector512.LoadUnsafe(ref second, offset)).ExtractMostSignificantBits(); 1306if (Vector512.IsHardwareAccelerated && remainder >= Vector512<byte>.Count * 2) 1312Vector512<byte> tempFirst = Vector512.LoadUnsafe(ref buf, (nuint)offset); 1313Vector512<byte> tempLast = Vector512.LoadUnsafe(ref buf, (nuint)lastOffset); 1323tempFirst = Vector512.Shuffle(tempFirst, Vector512.Create( 1328tempLast = Vector512.Shuffle(tempLast, Vector512.Create(

71if (Vector512.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector512<ushort>.Count >= 0) 80Vector512<ushort> ch1 = Vector512.Create((ushort)valueHead); 81Vector512<ushort> ch2 = Vector512.Create(ch2Val); 91Vector512<ushort> cmpCh2 = Vector512.Equals(ch2, Vector512.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance))); 92Vector512<ushort> cmpCh1 = Vector512.Equals(ch1, Vector512.LoadUnsafe(ref searchSpace, (nuint)offset)); 313if (Vector512.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector512<ushort>.Count) 324Vector512<ushort> ch1 = Vector512.Create((ushort)valueHead); 325Vector512<ushort> ch2 = Vector512.Create((ushort)ch2Val); 330Vector512<ushort> cmpCh1 = Vector512.Equals(ch1, Vector512.LoadUnsafe(ref searchSpace, (nuint)offset)); 331Vector512<ushort> cmpCh2 = Vector512.Equals(ch2, Vector512.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance))); 581if (Vector512.IsHardwareAccelerated) 654if (!Vector512.EqualsAny(search, Vector512<ushort>.Zero)) 667ulong matches = Vector512.Equals(search, Vector512<ushort>.Zero).ExtractMostSignificantBits(); 894if (Vector512.IsHardwareAccelerated && remainder >= Vector512<ushort>.Count * 2) 902Vector512<ushort> tempFirst = Vector512.LoadUnsafe(ref first); 903Vector512<ushort> tempLast = Vector512.LoadUnsafe(ref last); 913tempFirst = Vector512.Shuffle(tempFirst, Vector512.Create((ushort)31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 915tempLast = Vector512.Shuffle(tempLast, Vector512.Create((ushort)31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,

95if (Vector512.IsHardwareAccelerated && remainder >= Vector512<int>.Count * 2) 101Vector512<int> tempFirst = Vector512.LoadUnsafe(ref buf, (nuint)offset); 102Vector512<int> tempLast = Vector512.LoadUnsafe(ref buf, (nuint)lastOffset); 112tempFirst = Vector512.Shuffle(tempFirst, Vector512.Create(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); 113tempLast = Vector512.Shuffle(tempLast, Vector512.Create(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); 200if (Vector512.IsHardwareAccelerated && remainder >= Vector512<long>.Count * 2) 206Vector512<long> tempFirst = Vector512.LoadUnsafe(ref buf, (nuint)offset); 207Vector512<long> tempLast = Vector512.LoadUnsafe(ref buf, (nuint)lastOffset); 217tempFirst = Vector512.Shuffle(tempFirst, Vector512.Create(7, 6, 5, 4, 3, 2, 1, 0)); 218tempLast = Vector512.Shuffle(tempLast, Vector512.Create(7, 6, 5, 4, 3, 2, 1, 0));

149if (Avx512BW.IsSupported && Vector512.IsHardwareAccelerated && length > Vector512<short>.Count) 152Vector512<byte> packedValue = Vector512.Create((byte)value); 164Vector512<short> source0 = Vector512.LoadUnsafe(ref currentSearchSpace); 165Vector512<short> source1 = Vector512.LoadUnsafe(ref currentSearchSpace, (nuint)Vector512<short>.Count); 168if (Vector512.EqualsAny(packedValue, packedSource)) 187Vector512<short> source0 = Vector512.LoadUnsafe(ref firstVector); 188Vector512<short> source1 = Vector512.LoadUnsafe(ref oneVectorAwayFromEnd); 191if (Vector512.EqualsAny(packedValue, packedSource)) 348if (Avx512BW.IsSupported && Vector512.IsHardwareAccelerated && length > Vector512<short>.Count) 351Vector512<byte> packedValue = Vector512.Create((byte)value); 363Vector512<short> source0 = Vector512.LoadUnsafe(ref currentSearchSpace); 364Vector512<short> source1 = Vector512.LoadUnsafe(ref currentSearchSpace, (nuint)Vector512<short>.Count); 386Vector512<short> source0 = Vector512.LoadUnsafe(ref firstVector); 387Vector512<short> source1 = Vector512.LoadUnsafe(ref oneVectorAwayFromEnd); 557if (Avx512BW.IsSupported && Vector512.IsHardwareAccelerated && length > Vector512<short>.Count) 560Vector512<byte> packedValue0 = Vector512.Create((byte)value0); 561Vector512<byte> packedValue1 = Vector512.Create((byte)value1); 573Vector512<short> source0 = Vector512.LoadUnsafe(ref currentSearchSpace); 574Vector512<short> source1 = Vector512.LoadUnsafe(ref currentSearchSpace, (nuint)Vector512<short>.Count); 576Vector512<byte> result = NegateIfNeeded<TNegator>(Vector512.Equals(packedValue0, packedSource) | Vector512.Equals(packedValue1, packedSource)); 597Vector512<short> source0 = Vector512.LoadUnsafe(ref firstVector); 598Vector512<short> source1 = Vector512.LoadUnsafe(ref oneVectorAwayFromEnd); 600Vector512<byte> result = NegateIfNeeded<TNegator>(Vector512.Equals(packedValue0, packedSource) | Vector512.Equals(packedValue1, packedSource)); 772if (Avx512BW.IsSupported && Vector512.IsHardwareAccelerated && length > Vector512<short>.Count) 775Vector512<byte> packedValue0 = Vector512.Create((byte)value0); 776Vector512<byte> packedValue1 = Vector512.Create((byte)value1); 777Vector512<byte> packedValue2 = Vector512.Create((byte)value2); 789Vector512<short> source0 = Vector512.LoadUnsafe(ref currentSearchSpace); 790Vector512<short> source1 = Vector512.LoadUnsafe(ref currentSearchSpace, (nuint)Vector512<short>.Count); 792Vector512<byte> result = NegateIfNeeded<TNegator>(Vector512.Equals(packedValue0, packedSource) | Vector512.Equals(packedValue1, packedSource) | Vector512.Equals(packedValue2, packedSource)); 813Vector512<short> source0 = Vector512.LoadUnsafe(ref firstVector); 814Vector512<short> source1 = Vector512.LoadUnsafe(ref oneVectorAwayFromEnd); 816Vector512<byte> result = NegateIfNeeded<TNegator>(Vector512.Equals(packedValue0, packedSource) | Vector512.Equals(packedValue1, packedSource) | Vector512.Equals(packedValue2, packedSource)); 972if (Avx512BW.IsSupported && Vector512.IsHardwareAccelerated && length > Vector512<short>.Count) 975Vector512<byte> lowVector = Vector512.Create((byte)lowInclusive); 976Vector512<byte> rangeVector = Vector512.Create((byte)rangeInclusive); 988Vector512<short> source0 = Vector512.LoadUnsafe(ref currentSearchSpace); 989Vector512<short> source1 = Vector512.LoadUnsafe(ref currentSearchSpace, (nuint)Vector512<short>.Count); 1011Vector512<short> source0 = Vector512.LoadUnsafe(ref firstVector); 1012Vector512<short> source1 = Vector512.LoadUnsafe(ref oneVectorAwayFromEnd); 1202? Vector512.EqualsAny(left, right) : !Vector512.EqualsAll(left, right); 1210? Vector512.Equals(left, right) : ~Vector512.Equals(left, right); 1218? Vector512.LessThanOrEqualAny(left, right) : !Vector512.LessThanOrEqualAll(left, right); 1226? Vector512.LessThanOrEqual(left, right) : ~Vector512.LessThanOrEqual(left, right); 1318return Avx512F.PermuteVar8x64(result.AsInt64(), Vector512.Create(0, 2, 4, 6, 1, 3, 5, 7)).AsByte(); 1342public static Vector512<byte> TransformInput(Vector512<byte> input) => input | Vector512.Create((byte)0x20);

70vector = Vector512.Create(vec128).AsVector(); 87vector = Vector512.Create(vec256).AsVector(); 1387else if (Vector512.IsHardwareAccelerated && length >= Vector512<T>.Count) 1389Vector512<T> current, values = Vector512.Create(value); 1396current = Vector512.LoadUnsafe(ref currentSearchSpace); 1398if (Vector512.EqualsAny(values, current)) 1410current = Vector512.LoadUnsafe(ref oneVectorAwayFromEnd); 1412if (Vector512.EqualsAny(values, current)) 1578else if (Vector512.IsHardwareAccelerated && length >= Vector512<TValue>.Count) 1580Vector512<TValue> current, values = Vector512.Create(value); 1587current = Vector512.LoadUnsafe(ref currentSearchSpace); 1601current = Vector512.LoadUnsafe(ref oneVectorAwayFromEnd); 1803else if (Vector512.IsHardwareAccelerated && length >= Vector512<TValue>.Count) 1805Vector512<TValue> equals, current, values0 = Vector512.Create(value0), values1 = Vector512.Create(value1); 1812current = Vector512.LoadUnsafe(ref currentSearchSpace); 1813equals = TNegator.NegateIfNeeded(Vector512.Equals(values0, current) | Vector512.Equals(values1, current)); 1827current = Vector512.LoadUnsafe(ref oneVectorAwayFromEnd); 1828equals = TNegator.NegateIfNeeded(Vector512.Equals(values0, current) | Vector512.Equals(values1, current)); 2010else if (Vector512.IsHardwareAccelerated && length >= Vector512<TValue>.Count) 2012Vector512<TValue> equals, current, values0 = Vector512.Create(value0), values1 = Vector512.Create(value1), values2 = Vector512.Create(value2); 2019current = Vector512.LoadUnsafe(ref currentSearchSpace); 2020equals = TNegator.NegateIfNeeded(Vector512.Equals(values0, current) | Vector512.Equals(values1, current) | Vector512.Equals(values2, current)); 2034current = Vector512.LoadUnsafe(ref oneVectorAwayFromEnd); 2035equals = TNegator.NegateIfNeeded(Vector512.Equals(values0, current) | Vector512.Equals(values1, current) | Vector512.Equals(values2, current)); 2166else if (Vector512.IsHardwareAccelerated && length >= Vector512<TValue>.Count) 2168Vector512<TValue> equals, current, values0 = Vector512.Create(value0), values1 = Vector512.Create(value1), values2 = Vector512.Create(value2), values3 = Vector512.Create(value3); 2175current = Vector512.LoadUnsafe(ref currentSearchSpace); 2176equals = TNegator.NegateIfNeeded(Vector512.Equals(values0, current) | Vector512.Equals(values1, current) 2177| Vector512.Equals(values2, current) | Vector512.Equals(values3, current)); 2191current = Vector512.LoadUnsafe(ref oneVectorAwayFromEnd); 2192equals = TNegator.NegateIfNeeded(Vector512.Equals(values0, current) | Vector512.Equals(values1, current) 2193| Vector512.Equals(values2, current) | Vector512.Equals(values3, current)); 2329else if (Vector512.IsHardwareAccelerated && length >= Vector512<TValue>.Count) 2331Vector512<TValue> equals, current, values0 = Vector512.Create(value0), values1 = Vector512.Create(value1), 2332values2 = Vector512.Create(value2), values3 = Vector512.Create(value3), values4 = Vector512.Create(value4); 2339current = Vector512.LoadUnsafe(ref currentSearchSpace); 2340equals = TNegator.NegateIfNeeded(Vector512.Equals(values0, current) | Vector512.Equals(values1, current) | Vector512.Equals(values2, current) 2341| Vector512.Equals(values3, current) | Vector512.Equals(values4, current)); 2355current = Vector512.LoadUnsafe(ref oneVectorAwayFromEnd); 2356equals = TNegator.NegateIfNeeded(Vector512.Equals(values0, current) | Vector512.Equals(values1, current) | Vector512.Equals(values2, current) 2357| Vector512.Equals(values3, current) | Vector512.Equals(values4, current)); 2511else if (Vector512.IsHardwareAccelerated && length >= Vector512<TValue>.Count) 2650else if (Vector512.IsHardwareAccelerated && length >= Vector512<TValue>.Count) 2652Vector512<TValue> equals, current, values0 = Vector512.Create(value0), values1 = Vector512.Create(value1); 2658current = Vector512.LoadUnsafe(ref searchSpace, (nuint)(offset)); 2659equals = TNegator.NegateIfNeeded(Vector512.Equals(current, values0) | Vector512.Equals(current, values1)); 2672current = Vector512.LoadUnsafe(ref searchSpace); 2673equals = TNegator.NegateIfNeeded(Vector512.Equals(current, values0) | Vector512.Equals(current, values1)); 2835else if (Vector512.IsHardwareAccelerated && length >= Vector512<TValue>.Count) 2837Vector512<TValue> equals, current, values0 = Vector512.Create(value0), values1 = Vector512.Create(value1), values2 = Vector512.Create(value2); 2843current = Vector512.LoadUnsafe(ref searchSpace, (nuint)(offset)); 2844equals = TNegator.NegateIfNeeded(Vector512.Equals(current, values0) | Vector512.Equals(current, values1) | Vector512.Equals(current, values2)); 2857current = Vector512.LoadUnsafe(ref searchSpace); 2858equals = TNegator.NegateIfNeeded(Vector512.Equals(current, values0) | Vector512.Equals(current, values1) | Vector512.Equals(current, values2)); 2985else if (Vector512.IsHardwareAccelerated && length >= Vector512<TValue>.Count) 2987Vector512<TValue> equals, current, values0 = Vector512.Create(value0), values1 = Vector512.Create(value1), values2 = Vector512.Create(value2), values3 = Vector512.Create(value3); 2993current = Vector512.LoadUnsafe(ref searchSpace, (nuint)(offset)); 2994equals = TNegator.NegateIfNeeded(Vector512.Equals(current, values0) | Vector512.Equals(current, values1) 2995| Vector512.Equals(current, values2) | Vector512.Equals(current, values3)); 3007current = Vector512.LoadUnsafe(ref searchSpace); 3008equals = TNegator.NegateIfNeeded(Vector512.Equals(current, values0) | Vector512.Equals(current, values1) | Vector512.Equals(current, values2) | Vector512.Equals(current, values3)); 3145else if (!Vector512.IsHardwareAccelerated || length < (uint)Vector512<T>.Count) 3170Debug.Assert(Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported, "Vector512 is not HW-accelerated or not supported"); 3173Vector512<T> oldValues = Vector512.Create(oldValue); 3174Vector512<T> newValues = Vector512.Create(newValue); 3179original = Vector512.LoadUnsafe(ref src, idx); 3180mask = Vector512.Equals(oldValues, original); 3181result = Vector512.ConditionalSelect(mask, newValues, original); 3188original = Vector512.LoadUnsafe(ref src, lastVectorIndex); 3189mask = Vector512.Equals(oldValues, original); 3190result = Vector512.ConditionalSelect(mask, newValues, original); 3243else if (Vector512.IsHardwareAccelerated && length >= Vector512<TValue>.Count) 3245Vector512<TValue> equals, current, values0 = Vector512.Create(value0), values1 = Vector512.Create(value1), 3246values2 = Vector512.Create(value2), values3 = Vector512.Create(value3), values4 = Vector512.Create(value4); 3252current = Vector512.LoadUnsafe(ref searchSpace, (nuint)(offset)); 3253equals = TNegator.NegateIfNeeded(Vector512.Equals(current, values0) | Vector512.Equals(current, values1) | Vector512.Equals(current, values2) 3254| Vector512.Equals(current, values3) | Vector512.Equals(current, values4)); 3266current = Vector512.LoadUnsafe(ref searchSpace); 3267equals = TNegator.NegateIfNeeded(Vector512.Equals(current, values0) | Vector512.Equals(current, values1) | Vector512.Equals(current, values2) 3268| Vector512.Equals(current, values3) | Vector512.Equals(current, values4)); 3561else if (!Vector512.IsHardwareAccelerated || length < (uint)Vector512<T>.Count) 3592Vector512<T> lowVector = Vector512.Create(lowInclusive); 3593Vector512<T> rangeVector = Vector512.Create(highInclusive - lowInclusive); 3602inRangeVector = TNegator.NegateIfNeeded(Vector512.LessThanOrEqual(Vector512.LoadUnsafe(ref current) - lowVector, rangeVector)); 3613inRangeVector = TNegator.NegateIfNeeded(Vector512.LessThanOrEqual(Vector512.LoadUnsafe(ref oneVectorAwayFromEnd) - lowVector, rangeVector)); 3706else if (!Vector512.IsHardwareAccelerated || length < Vector512<T>.Count) 3735Vector512<T> lowVector = Vector512.Create(lowInclusive); 3736Vector512<T> rangeVector = Vector512.Create(highInclusive - lowInclusive); 3744inRangeVector = TNegator.NegateIfNeeded(Vector512.LessThanOrEqual(Vector512.LoadUnsafe(ref searchSpace, (nuint)offset) - lowVector, rangeVector)); 3754inRangeVector = TNegator.NegateIfNeeded(Vector512.LessThanOrEqual(Vector512.LoadUnsafe(ref searchSpace) - lowVector, rangeVector)); 3804if (Vector512.IsHardwareAccelerated && length >= Vector512<T>.Count) 3806Vector512<T> targetVector = Vector512.Create(value); 3810count += BitOperations.PopCount(Vector512.Equals(Vector512.LoadUnsafe(ref current), targetVector).ExtractMostSignificantBits()); 3815ulong mask = Vector512.Equals(Vector512.LoadUnsafe(ref oneVectorAwayFromEnd), targetVector).ExtractMostSignificantBits();

1300if (Vector512.IsHardwareAccelerated && length >= (uint)Vector512<ushort>.Count) 2043if (Vector512.IsHardwareAccelerated && lengthToExamine >= (uint)Vector512<ushort>.Count*2) 2045Vector512<ushort> v1 = Vector512.Create((ushort)c); 2046Vector512<ushort> v2 = Vector512.Create((ushort)c2); 2047Vector512<ushort> v3 = Vector512.Create((ushort)c3); 2051Vector512<ushort> vector = Vector512.LoadUnsafe(ref source, offset); 2052Vector512<ushort> v1Eq = Vector512.Equals(vector, v1); 2053Vector512<ushort> v2Eq = Vector512.Equals(vector, v2); 2054Vector512<ushort> v3Eq = Vector512.Equals(vector, v3);

65else if (Vector512.IsHardwareAccelerated && length >= (uint)Vector512<TLeft>.Count) 235else if (Vector512.IsHardwareAccelerated && length >= (uint)Vector512<TRight>.Count) 245Vector512<TRight> loweringMask = Vector512.Create(TRight.CreateTruncating(0x20)); 246Vector512<TRight> vecA = Vector512.Create(TRight.CreateTruncating('a')); 247Vector512<TRight> vecZMinusA = Vector512.Create(TRight.CreateTruncating(('z' - 'a'))); 253rightValues = Vector512.LoadUnsafe(ref currentRightSearchSpace); 259Vector512<TRight> notEquals = ~Vector512.Equals(leftValues, rightValues); 268if (Vector512.GreaterThanAny((leftValues - vecA) & notEquals, vecZMinusA) || leftValues != rightValues) 283rightValues = Vector512.LoadUnsafe(ref oneVectorAwayFromRightEnd); 290Vector512<TRight> notEquals = ~Vector512.Equals(leftValues, rightValues); 299if (Vector512.GreaterThanAny((leftValues - vecA) & notEquals, vecZMinusA) || leftValues != rightValues) 476public static Vector512<T> Load512(ref T ptr) => Vector512.LoadUnsafe(ref ptr); 496Vector512<T> leftValues = Vector512.LoadUnsafe(ref left); 497Vector512<T> rightValues = Vector512.LoadUnsafe(ref right); 548return Vector512.WidenLower(Vector256.LoadUnsafe(ref ptr).ToVector512()); 583Vector512<byte> leftNotWidened = Vector512.LoadUnsafe(ref utf8); 589(Vector512<ushort> leftLower, Vector512<ushort> leftUpper) = Vector512.Widen(leftNotWidened); 590Vector512<ushort> right = Vector512.LoadUnsafe(ref utf16); 591Vector512<ushort> rightNext = Vector512.LoadUnsafe(ref utf16, (uint)Vector512<ushort>.Count);

115if (!Vector512.IsHardwareAccelerated && 143if (Vector512.IsHardwareAccelerated && bufferLength >= 2 * (uint)Vector512<byte>.Count) 145if (Vector512.Load(pBuffer).ExtractMostSignificantBits() == 0) 151byte* pFinalVectorReadPos = pBuffer + bufferLength - Vector512.Size; 152pBuffer = (byte*)(((nuint)pBuffer + Vector512.Size) & ~(nuint)(Vector512.Size - 1)); 156Debug.Assert(0 < numBytesRead && numBytesRead <= Vector512.Size, "We should've made forward progress of at least one byte."); 164Debug.Assert((nuint)pBuffer % Vector512.Size == 0, "Vector read should be aligned."); 165if (Vector512.LoadAligned(pBuffer).ExtractMostSignificantBits() != 0) 170pBuffer += Vector512.Size; 735if (!Vector512.IsHardwareAccelerated && 763if (Vector512.IsHardwareAccelerated && bufferLength >= 2 * (uint)Vector512<ushort>.Count) 765const uint SizeOfVector512InChars = Vector512.Size / sizeof(ushort); 767if (!VectorContainsNonAsciiChar(Vector512.Load((ushort*)pBuffer))) 774pBuffer = (char*)(((nuint)pBuffer + Vector512.Size) & ~(nuint)(Vector512.Size - 1)); 786Debug.Assert((nuint)pBuffer % Vector512.Size == 0, "Vector read should be aligned."); 787if (VectorContainsNonAsciiChar(Vector512.LoadAligned((ushort*)pBuffer))) 1373if (Vector512.IsHardwareAccelerated && elementCount >= 2 * (uint)Vector512<byte>.Count) 1592Vector512<ushort> zeroIsAscii = utf16Vector & Vector512.Create(asciiMask); 1661return (vector.AsUInt16() & Vector512.Create((ushort)0xFF80)) == Vector512<ushort>.Zero; 1703: Vector512.Narrow(vectorFirst, vectorSecond); 1950const nuint MaskOfAllBitsInVector512 = (nuint)(Vector512.Size - 1); 1956Debug.Assert(Vector512.IsHardwareAccelerated, "Vector512 is required."); 1958Debug.Assert(elementCount >= 2 * Vector512.Size); 1962Vector512<ushort> utf16VectorFirst = Vector512.LoadUnsafe(ref utf16Buffer); 1975nuint currentOffsetInElements = Vector512.Size / 2; // we processed 32 elements so far 1988if (((uint)pAsciiBuffer & (Vector512.Size / 2)) == 0) 1992utf16VectorFirst = Vector512.LoadUnsafe(ref utf16Buffer, currentOffsetInElements); 2007currentOffsetInElements = Vector512.Size - ((nuint)pAsciiBuffer & MaskOfAllBitsInVector512); 2009Debug.Assert(0 < currentOffsetInElements && currentOffsetInElements <= Vector512.Size, "We wrote at least 1 byte but no more than a whole vector."); 2011Debug.Assert(elementCount - currentOffsetInElements >= Vector512.Size, "We should be able to run at least one whole vector."); 2013nuint finalOffsetWhereCanRunLoop = elementCount - Vector512.Size; 2018utf16VectorFirst = Vector512.LoadUnsafe(ref utf16Buffer, currentOffsetInElements); 2019Vector512<ushort> utf16VectorSecond = Vector512.LoadUnsafe(ref utf16Buffer, currentOffsetInElements + Vector512.Size / sizeof(short)); 2029Debug.Assert(((nuint)pAsciiBuffer + currentOffsetInElements) % Vector512.Size == 0, "Write should be aligned."); 2033currentOffsetInElements += Vector512.Size; 2055currentOffsetInElements += Vector512.Size / 2; 2075if (Vector512.IsHardwareAccelerated && (elementCount - currentOffset) >= (uint)Vector512<byte>.Count) 2256(Vector512<ushort> Lower512, Vector512<ushort> Upper512) = Vector512.Widen((Vector512<byte>)(object)vector);

18[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.Intrinsics.Vector512))]

129while (Vector512.IsHardwareAccelerated && d.Length - offset >= Vector512<uint>.Count) 131Vector512<uint> complement = ~Vector512.LoadUnsafe(ref start, (nuint)offset); 132Vector512.StoreUnsafe(complement, ref start, (nuint)offset);