8058 references to Vector256
GenerateDocumentationAndConfigFiles (34)
src\roslyn\src\Compilers\Core\Portable\Hashing\XxHashShared.cs (34)
494Vector256<ulong> seedVec = Vector256.Create(seed, 0u - seed, seed, 0u - seed); 495for (int i = 0; i < SecretLengthBytes; i += Vector256<byte>.Count) 530Vector256<ulong> acc1 = Vector256.Load(accumulators); 531Vector256<ulong> acc2 = Vector256.Load(accumulators + Vector256<ulong>.Count); 538Vector256<uint> secretVal = Vector256.Load((uint*)secret); 540source += Vector256<byte>.Count; 542secretVal = Vector256.Load((uint*)secret + Vector256<uint>.Count); 544source += Vector256<byte>.Count; 552acc2 = ScrambleAccumulator256(acc2, Vector256.Load((ulong*)secretForScramble + Vector256<ulong>.Count)); 557Vector256.Store(acc2, accumulators + Vector256<ulong>.Count); 635for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 637Vector256<ulong> accVec = Accumulate256(Vector256.Load(accumulators), source, Vector256.Load((uint*)secret)); 640accumulators += Vector256<ulong>.Count; 641secret += Vector256<byte>.Count; 642source += Vector256<byte>.Count; 673private static Vector256<ulong> Accumulate256(Vector256<ulong> accVec, byte* source, Vector256<uint> secret) 675Vector256<uint> sourceVec = Vector256.Load((uint*)source); 676Vector256<uint> sourceKey = sourceVec ^ secret; 679Vector256<uint> sourceKeyLow = Vector256.Shuffle(sourceKey, Vector256.Create(1u, 0, 3, 0, 5, 0, 7, 0)); 680Vector256<uint> sourceSwap = Vector256.Shuffle(sourceVec, Vector256.Create(2u, 3, 0, 1, 6, 7, 4, 5)); 681Vector256<ulong> sum = accVec + sourceSwap.AsUInt64(); 682Vector256<ulong> product = Avx2.IsSupported ? 729for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 731Vector256<ulong> accVec = ScrambleAccumulator256(Vector256.Load(accumulators), Vector256.Load((ulong*)secret)); 734accumulators += Vector256<ulong>.Count; 735secret += Vector256<byte>.Count; 766private static Vector256<ulong> ScrambleAccumulator256(Vector256<ulong> accVec, Vector256<ulong> secret) 768Vector256<ulong> xorShift = accVec ^ Vector256.ShiftRightLogical(accVec, 47); 769Vector256<ulong> xorWithKey = xorShift ^ secret;
Microsoft.AspNetCore.Razor.Utilities.Shared (34)
Utilities\Hashing\XxHashShared.cs (34)
493Vector256<ulong> seedVec = Vector256.Create(seed, 0u - seed, seed, 0u - seed); 494for (int i = 0; i < SecretLengthBytes; i += Vector256<byte>.Count) 529Vector256<ulong> acc1 = Vector256.Load(accumulators); 530Vector256<ulong> acc2 = Vector256.Load(accumulators + Vector256<ulong>.Count); 537Vector256<uint> secretVal = Vector256.Load((uint*)secret); 539source += Vector256<byte>.Count; 541secretVal = Vector256.Load((uint*)secret + Vector256<uint>.Count); 543source += Vector256<byte>.Count; 551acc2 = ScrambleAccumulator256(acc2, Vector256.Load((ulong*)secretForScramble + Vector256<ulong>.Count)); 556Vector256.Store(acc2, accumulators + Vector256<ulong>.Count); 634for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 636Vector256<ulong> accVec = Accumulate256(Vector256.Load(accumulators), source, Vector256.Load((uint*)secret)); 639accumulators += Vector256<ulong>.Count; 640secret += Vector256<byte>.Count; 641source += Vector256<byte>.Count; 672private static Vector256<ulong> Accumulate256(Vector256<ulong> accVec, byte* source, Vector256<uint> secret) 674Vector256<uint> sourceVec = Vector256.Load((uint*)source); 675Vector256<uint> sourceKey = sourceVec ^ secret; 678Vector256<uint> sourceKeyLow = Vector256.Shuffle(sourceKey, Vector256.Create(1u, 0, 3, 0, 5, 0, 7, 0)); 679Vector256<uint> sourceSwap = Vector256.Shuffle(sourceVec, Vector256.Create(2u, 3, 0, 1, 6, 7, 4, 5)); 680Vector256<ulong> sum = accVec + sourceSwap.AsUInt64(); 681Vector256<ulong> product = Avx2.IsSupported ? 728for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 730Vector256<ulong> accVec = ScrambleAccumulator256(Vector256.Load(accumulators), Vector256.Load((ulong*)secret)); 733accumulators += Vector256<ulong>.Count; 734secret += Vector256<byte>.Count; 765private static Vector256<ulong> ScrambleAccumulator256(Vector256<ulong> accVec, Vector256<ulong> secret) 767Vector256<ulong> xorShift = accVec ^ Vector256.ShiftRightLogical(accVec, 47); 768Vector256<ulong> xorWithKey = xorShift ^ secret;
Microsoft.CodeAnalysis (34)
Hashing\XxHashShared.cs (34)
494Vector256<ulong> seedVec = Vector256.Create(seed, 0u - seed, seed, 0u - seed); 495for (int i = 0; i < SecretLengthBytes; i += Vector256<byte>.Count) 530Vector256<ulong> acc1 = Vector256.Load(accumulators); 531Vector256<ulong> acc2 = Vector256.Load(accumulators + Vector256<ulong>.Count); 538Vector256<uint> secretVal = Vector256.Load((uint*)secret); 540source += Vector256<byte>.Count; 542secretVal = Vector256.Load((uint*)secret + Vector256<uint>.Count); 544source += Vector256<byte>.Count; 552acc2 = ScrambleAccumulator256(acc2, Vector256.Load((ulong*)secretForScramble + Vector256<ulong>.Count)); 557Vector256.Store(acc2, accumulators + Vector256<ulong>.Count); 635for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 637Vector256<ulong> accVec = Accumulate256(Vector256.Load(accumulators), source, Vector256.Load((uint*)secret)); 640accumulators += Vector256<ulong>.Count; 641secret += Vector256<byte>.Count; 642source += Vector256<byte>.Count; 673private static Vector256<ulong> Accumulate256(Vector256<ulong> accVec, byte* source, Vector256<uint> secret) 675Vector256<uint> sourceVec = Vector256.Load((uint*)source); 676Vector256<uint> sourceKey = sourceVec ^ secret; 679Vector256<uint> sourceKeyLow = Vector256.Shuffle(sourceKey, Vector256.Create(1u, 0, 3, 0, 5, 0, 7, 0)); 680Vector256<uint> sourceSwap = Vector256.Shuffle(sourceVec, Vector256.Create(2u, 3, 0, 1, 6, 7, 4, 5)); 681Vector256<ulong> sum = accVec + sourceSwap.AsUInt64(); 682Vector256<ulong> product = Avx2.IsSupported ? 729for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 731Vector256<ulong> accVec = ScrambleAccumulator256(Vector256.Load(accumulators), Vector256.Load((ulong*)secret)); 734accumulators += Vector256<ulong>.Count; 735secret += Vector256<byte>.Count; 766private static Vector256<ulong> ScrambleAccumulator256(Vector256<ulong> accVec, Vector256<ulong> secret) 768Vector256<ulong> xorShift = accVec ^ Vector256.ShiftRightLogical(accVec, 47); 769Vector256<ulong> xorWithKey = xorShift ^ secret;
Microsoft.CodeAnalysis.Workspaces (34)
src\roslyn\src\Compilers\Core\Portable\Hashing\XxHashShared.cs (34)
494Vector256<ulong> seedVec = Vector256.Create(seed, 0u - seed, seed, 0u - seed); 495for (int i = 0; i < SecretLengthBytes; i += Vector256<byte>.Count) 530Vector256<ulong> acc1 = Vector256.Load(accumulators); 531Vector256<ulong> acc2 = Vector256.Load(accumulators + Vector256<ulong>.Count); 538Vector256<uint> secretVal = Vector256.Load((uint*)secret); 540source += Vector256<byte>.Count; 542secretVal = Vector256.Load((uint*)secret + Vector256<uint>.Count); 544source += Vector256<byte>.Count; 552acc2 = ScrambleAccumulator256(acc2, Vector256.Load((ulong*)secretForScramble + Vector256<ulong>.Count)); 557Vector256.Store(acc2, accumulators + Vector256<ulong>.Count); 635for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 637Vector256<ulong> accVec = Accumulate256(Vector256.Load(accumulators), source, Vector256.Load((uint*)secret)); 640accumulators += Vector256<ulong>.Count; 641secret += Vector256<byte>.Count; 642source += Vector256<byte>.Count; 673private static Vector256<ulong> Accumulate256(Vector256<ulong> accVec, byte* source, Vector256<uint> secret) 675Vector256<uint> sourceVec = Vector256.Load((uint*)source); 676Vector256<uint> sourceKey = sourceVec ^ secret; 679Vector256<uint> sourceKeyLow = Vector256.Shuffle(sourceKey, Vector256.Create(1u, 0, 3, 0, 5, 0, 7, 0)); 680Vector256<uint> sourceSwap = Vector256.Shuffle(sourceVec, Vector256.Create(2u, 3, 0, 1, 6, 7, 4, 5)); 681Vector256<ulong> sum = accVec + sourceSwap.AsUInt64(); 682Vector256<ulong> product = Avx2.IsSupported ? 729for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 731Vector256<ulong> accVec = ScrambleAccumulator256(Vector256.Load(accumulators), Vector256.Load((ulong*)secret)); 734accumulators += Vector256<ulong>.Count; 735secret += Vector256<byte>.Count; 766private static Vector256<ulong> ScrambleAccumulator256(Vector256<ulong> accVec, Vector256<ulong> secret) 768Vector256<ulong> xorShift = accVec ^ Vector256.ShiftRightLogical(accVec, 47); 769Vector256<ulong> xorWithKey = xorShift ^ secret;
Microsoft.ML.CpuMath (165)
AvxIntrinsics.cs (131)
50private static readonly Vector256<float> _absMask256 = Vector256.Create(0x7FFFFFFF).AsSingle(); 72private static Vector128<float> GetHigh(in Vector256<float> x) 76private static unsafe Vector256<float> Load8(float* src, int* idx) 80Vector256<int> idx256 = Avx.LoadVector256(idx); 90private static unsafe void Store8(in Vector256<float> x, float* dst, int* idx) 111private static Vector256<float> VectorSum256(in Vector256<float> vector) 113Vector256<float> partialSum = Avx.HorizontalAdd(vector, vector); 118private static Vector256<float> VectorMax256(in Vector256<float> vector) 121Vector256<float> x1 = Avx.Shuffle(vector, vector, 0xB1); 125Vector256<float> partialMax = Avx.Max(vector, x1); 137private static Vector256<float> GetNewDst256(in Vector256<float> xDst1, in Vector256<float> xThreshold) 139Vector256<float> signMask = Vector256.Create(-0.0f); // 0x8000 0000 140Vector256<float> xSign = Avx.And(xDst1, signMask); // result = 0x8000 0000 if xDst1 is negative or 0x0000 0000 otherwise 141Vector256<float> xDst1Abs = Avx.Xor(xDst1, xSign); 142Vector256<float> xCond = Avx.Compare(xDst1Abs, xThreshold, FloatComparisonMode.OrderedGreaterThanNonSignaling); // result = 0xFFFF FFFF if true 143Vector256<float> x2 = Avx.Xor(xSign, xThreshold); // -xThreshold if xDst1 is negative and +xThreshold otherwise 148private static unsafe Vector256<float> MultiplyAdd(float* psrc1, Vector256<float> src2, Vector256<float> src3) 156Vector256<float> product = Avx.Multiply(src2, Avx.LoadVector256(psrc1)); 162private static Vector256<float> MultiplyAdd(Vector256<float> src1, Vector256<float> src2, Vector256<float> src3) 170Vector256<float> product = Avx.Multiply(src1, src2); 197Vector256<float> res0 = Vector256<float>.Zero; 198Vector256<float> res1 = res0; 199Vector256<float> res2 = res0; 200Vector256<float> res3 = res0; 215Vector256<float> x01 = Avx.LoadVector256(pMatTemp); 216Vector256<float> x11 = Avx.LoadVector256(pMatTemp += ccol); 217Vector256<float> x21 = Avx.LoadVector256(pMatTemp += ccol); 218Vector256<float> x31 = Avx.LoadVector256(pMatTemp += ccol); 219Vector256<float> x02 = Avx.LoadVector256(pSrcCurrent); 275Vector256<float> result = Vector256<float>.Zero; 283Vector256<float> x1 = Vector256.Create(pm0[col1], pm1[col1], pm2[col1], pm3[col1], 285Vector256<float> x2 = Vector256.Create(pSrcCurrent[col1]); 326Vector256<float> x01 = Vector256.Create(h01, h01); 327Vector256<float> x11 = Vector256.Create(h11, h11); 328Vector256<float> x21 = Vector256.Create(h21, h21); 329Vector256<float> x31 = Vector256.Create(h31, h31); 345Vector256<float> x02 = Avx.LoadVector256(pMatTemp); 346Vector256<float> x12 = Avx.LoadVector256(pMatTemp += crow); 347Vector256<float> x22 = Avx.LoadVector256(pMatTemp += crow); 348Vector256<float> x32 = Avx.LoadVector256(pMatTemp += crow); 393Vector256<float> x02 = Avx.LoadVector256(pMatTemp); 394Vector256<float> x12 = Avx.LoadVector256(pMatTemp += crow); 395Vector256<float> x22 = Avx.LoadVector256(pMatTemp += crow); 396Vector256<float> x32 = Avx.LoadVector256(pMatTemp += crow); 397Vector256<float> x3 = Avx.LoadVector256(pDstCurrent); 428Vector256<float> scalarVector256 = Vector256.Create(scalar); 432Vector256<float> dstVector = Avx.LoadVector256(pDstCurrent); 469Vector256<float> scaleVector256 = Vector256.Create(scale); 482Vector256<float> temp = Avx.LoadVector256(pDstCurrent); 497Vector256<float> result = Avx.LoadVector256(pDstCurrent); 499Vector256<float> leadingMask = Avx.LoadVector256(((float*)(pLeadingAlignmentMask)) + (misalignment * 8)); 500Vector256<float> trailingMask = Avx.LoadVector256(((float*)(pTrailingAlignmentMask)) + ((8 - misalignment) * 8)); 502Vector256<float> temp = Avx.And(result, trailingMask); 530Vector256<float> temp = Avx.LoadVector256(pDstCurrent); 551Vector256<float> result = Avx.LoadVector256(pDstCurrent); 553Vector256<float> trailingMask = Avx.LoadVector256(((float*)(pTrailingAlignmentMask)) + (remainder * 8)); 554Vector256<float> leadingMask = Avx.LoadVector256(((float*)(pLeadingAlignmentMask)) + ((8 - remainder) * 8)); 556Vector256<float> temp = Avx.And(result, leadingMask); 580Vector256<float> scaleVector256 = Vector256.Create(scale); 584Vector256<float> srcVector = Avx.LoadVector256(pSrcCurrent); 625Vector256<float> a256 = Vector256.Create(a); 626Vector256<float> b256 = Vector256.Create(b); 630Vector256<float> dstVector = Avx.LoadVector256(pDstCurrent); 674Vector256<float> scaleVector256 = Vector256.Create(scale); 678Vector256<float> dstVector = Avx.LoadVector256(pDstCurrent); 731Vector256<float> scaleVector256 = Vector256.Create(scale); 735Vector256<float> dstVector = Avx.LoadVector256(pDstCurrent); 788Vector256<float> scaleVector256 = Vector256.Create(scale); 792Vector256<float> dstVector = Load8(pDstCurrent, pIdxCurrent); 838Vector256<float> srcVector = Avx.LoadVector256(pSrcCurrent); 839Vector256<float> dstVector = Avx.LoadVector256(pDstCurrent); 841Vector256<float> result = Avx.Add(srcVector, dstVector); 890Vector256<float> dstVector = Load8(pDstCurrent, pIdxCurrent); 891Vector256<float> srcVector = Avx.LoadVector256(pSrcCurrent); 938Vector256<float> src1Vector = Avx.LoadVector256(pSrc1Current); 939Vector256<float> src2Vector = Avx.LoadVector256(pSrc2Current); 982Vector256<float> result = Vector256<float>.Zero; 1009Vector256<float> mask = Avx.LoadVector256(((float*)(pLeadingAlignmentMask)) + (misalignment * 8)); 1010Vector256<float> temp = Avx.And(mask, Avx.LoadVector256(pValues)); 1051Vector256<float> mask = Avx.LoadVector256(((float*)(pTrailingAlignmentMask)) + (remainder * 8)); 1052Vector256<float> temp = Avx.And(mask, Avx.LoadVector256(pValues)); 1069Vector256<float> result256 = Vector256<float>.Zero; 1073Vector256<float> srcVector = Avx.LoadVector256(pSrcCurrent); 1113Vector256<float> result256 = Vector256<float>.Zero; 1114Vector256<float> meanVector256 = Vector256.Create(mean); 1118Vector256<float> srcVector = Avx.LoadVector256(pSrcCurrent); 1161Vector256<float> result256 = Vector256<float>.Zero; 1165Vector256<float> srcVector = Avx.LoadVector256(pSrcCurrent); 1205Vector256<float> result256 = Vector256<float>.Zero; 1206Vector256<float> meanVector256 = Vector256.Create(mean); 1210Vector256<float> srcVector = Avx.LoadVector256(pSrcCurrent); 1254Vector256<float> result256 = Vector256<float>.Zero; 1258Vector256<float> srcVector = Avx.LoadVector256(pSrcCurrent); 1298Vector256<float> result256 = Vector256<float>.Zero; 1299Vector256<float> meanVector256 = Vector256.Create(mean); 1303Vector256<float> srcVector = Avx.LoadVector256(pSrcCurrent); 1351Vector256<float> result256 = Vector256<float>.Zero; 1355Vector256<float> dstVector = Avx.LoadVector256(pDstCurrent); 1408Vector256<float> result256 = Vector256<float>.Zero; 1412Vector256<float> srcVector = Load8(pSrcCurrent, pIdxCurrent); 1462Vector256<float> sqDistanceVector256 = Vector256<float>.Zero; 1466Vector256<float> distanceVector = Avx.Subtract(Avx.LoadVector256(pSrcCurrent), 1516Vector256<float> xPrimal256 = Vector256.Create(primalUpdate); 1517Vector256<float> xThreshold256 = Vector256.Create(threshold); 1521Vector256<float> xDst1 = Avx.LoadVector256(pDst1Current); 1523Vector256<float> xDst2 = GetNewDst256(xDst1, xThreshold256); 1576Vector256<float> xPrimal256 = Vector256.Create(primalUpdate); 1577Vector256<float> xThreshold = Vector256.Create(threshold); 1581Vector256<float> xDst1 = Load8(pdst1, pIdxCurrent); 1583Vector256<float> xDst2 = GetNewDst256(xDst1, xThreshold);
FactorizationMachine\AvxIntrinsics.cs (34)
15private static readonly Vector256<float> _point5 = Vector256.Create(0.5f); 18private static Vector256<float> MultiplyAdd(Vector256<float> src1, Vector256<float> src2, Vector256<float> src3) 26Vector256<float> product = Avx.Multiply(src1, src2); 32private static Vector256<float> MultiplyAddNegated(Vector256<float> src1, Vector256<float> src2, Vector256<float> src3) 40Vector256<float> product = Avx.Multiply(src1, src2); 69Vector256<float> y = Vector256<float>.Zero; 70Vector256<float> tmp = Vector256<float>.Zero; 78Vector256<float> x = Avx.BroadcastScalarToVector256(px + i); 79Vector256<float> xx = Avx.Multiply(x, x); 89Vector256<float> vjfBuffer = Avx.LoadVector256(vjf + k); 103Vector256<float> vjfprimeBuffer = Avx.LoadVector256(vjfprime + k); 104Vector256<float> q = Avx.LoadVector256(qffprime + k); 117Vector256<float> qffBuffer = Avx.LoadVector256(qff + k); 132Vector256<float> qffprimeBuffer = Avx.LoadVector256(qffprime + k); 133Vector256<float> qfprimefBuffer = Avx.LoadVector256(qfprimef + k); 167Vector256<float> wei = Vector256.Create(weight); 168Vector256<float> s = Vector256.Create(slope); 169Vector256<float> lr = Vector256.Create(learningRate); 170Vector256<float> lambdav = Vector256.Create(lambdaLatent); 187Vector256<float> x = Avx.BroadcastScalarToVector256(px + i); 194Vector256<float> sx = Avx.Multiply(s, x); 198Vector256<float> v = Avx.LoadVector256(vjfprime + k); 199Vector256<float> q = Avx.LoadVector256(qfprimef + k); 202Vector256<float> gLatent = Avx.Multiply(lambdav, v); 204Vector256<float> tmp = q; 213Vector256<float> h = MultiplyAdd(gLatent, gLatent, Avx.LoadVector256(hvjfprime + k));
System.IO.Hashing (50)
System\IO\Hashing\Adler32.cs (16)
205if (Vector256.IsHardwareAccelerated && Avx2.IsSupported && source.Length >= Vector256<byte>.Count) 365Debug.Assert(source.Length >= Vector256<byte>.Count); 375Vector256<sbyte> weights = Vector256.Create(32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1); 384Vector256<uint> vs1 = Vector256.CreateScalar(s1); 385Vector256<uint> vs2 = Vector256.CreateScalar(s2); 386Vector256<uint> vs3 = Vector256<uint>.Zero; 390Vector256<byte> data = Vector256.LoadUnsafe(ref sourceRef); 393Vector256<uint> vs1_0 = vs1; 394vs1 += Avx2.SumAbsoluteDifferences(data, Vector256<byte>.Zero).AsUInt32(); 397Vector256<short> mad = Avx2.MultiplyAddAdjacent(data, weights); 398vs2 += Avx2.MultiplyAddAdjacent(mad, Vector256<short>.One).AsUInt32(); 459Vector256<uint> sumLo = Avx2.SumAbsoluteDifferences(data.GetLower(), Vector256<byte>.Zero).AsUInt32(); 460vs2 += Vector512.Create(sumLo << 5, Vector256<uint>.Zero); 475if (length >= Vector256<byte>.Count)
System\IO\Hashing\XxHashShared.cs (34)
486Vector256<ulong> seedVec = Vector256.Create(seed, 0u - seed, seed, 0u - seed); 487for (int i = 0; i < SecretLengthBytes; i += Vector256<byte>.Count) 522Vector256<ulong> acc1 = Vector256.Load(accumulators); 523Vector256<ulong> acc2 = Vector256.Load(accumulators + Vector256<ulong>.Count); 530Vector256<uint> secretVal = Vector256.Load((uint*)secret); 532source += Vector256<byte>.Count; 534secretVal = Vector256.Load((uint*)secret + Vector256<uint>.Count); 536source += Vector256<byte>.Count; 544acc2 = ScrambleAccumulator256(acc2, Vector256.Load((ulong*)secretForScramble + Vector256<ulong>.Count)); 549Vector256.Store(acc2, accumulators + Vector256<ulong>.Count); 627for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 629Vector256<ulong> accVec = Accumulate256(Vector256.Load(accumulators), source, Vector256.Load((uint*)secret)); 632accumulators += Vector256<ulong>.Count; 633secret += Vector256<byte>.Count; 634source += Vector256<byte>.Count; 665private static Vector256<ulong> Accumulate256(Vector256<ulong> accVec, byte* source, Vector256<uint> secret) 667Vector256<uint> sourceVec = Vector256.Load((uint*)source); 668Vector256<uint> sourceKey = sourceVec ^ secret; 671Vector256<uint> sourceKeyLow = Vector256.Shuffle(sourceKey, Vector256.Create(1u, 0, 3, 0, 5, 0, 7, 0)); 672Vector256<uint> sourceSwap = Vector256.Shuffle(sourceVec, Vector256.Create(2u, 3, 0, 1, 6, 7, 4, 5)); 673Vector256<ulong> sum = accVec + sourceSwap.AsUInt64(); 674Vector256<ulong> product = Avx2.IsSupported ? 734for (int i = 0; i < AccumulatorCount / Vector256<ulong>.Count; i++) 736Vector256<ulong> accVec = ScrambleAccumulator256(Vector256.Load(accumulators), Vector256.Load((ulong*)secret)); 739accumulators += Vector256<ulong>.Count; 740secret += Vector256<byte>.Count; 771private static Vector256<ulong> ScrambleAccumulator256(Vector256<ulong> accVec, Vector256<ulong> secret) 773Vector256<ulong> xorShift = accVec ^ Vector256.ShiftRightLogical(accVec, 47); 774Vector256<ulong> xorWithKey = xorShift ^ secret;
System.Numerics.Tensors (1971)
System\Numerics\Tensors\netcore\Common\TensorPrimitives.IAggregationOperator.cs (148)
19static abstract T Invoke(Vector256<T> x); 34public Vector256<T> Invoke(Vector256<T> x) => TOperator.Invoke(x); 92if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TTransformOperator.Vectorizable) 96if (remainder >= (uint)Vector256<T>.Count) 333Vector256<T> vresult = Vector256.Create(TAggregationOperator.IdentityValue); 337Vector256<T> beg = transform.Invoke(Vector256.LoadUnsafe(ref xRef)); 338Vector256<T> end = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 342if (remainder > (uint)(Vector256<T>.Count * 8)) 368misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)xPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T); 372Debug.Assert(((nuint)xPtr % (uint)sizeof(Vector256<T>)) == 0); 382misalignment = (uint)Vector256<T>.Count; 387Vector256<T> vector1; 388Vector256<T> vector2; 389Vector256<T> vector3; 390Vector256<T> vector4; 394while (remainder >= (uint)(Vector256<T>.Count * 8)) 398vector1 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0))); 399vector2 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1))); 400vector3 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2))); 401vector4 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3))); 410vector1 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4))); 411vector2 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5))); 412vector3 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6))); 413vector4 = transform.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7))); 423xPtr += (uint)(Vector256<T>.Count * 8); 425remainder -= (uint)(Vector256<T>.Count * 8); 446(nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector256<T>.Count); 454Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7))); 461Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6))); 468Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5))); 475Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4))); 482Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3))); 489Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2))); 496Vector256<T> vector = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 1))); 760Vector256<T> beg = transform.Invoke(Vector256.LoadUnsafe(ref xRef)); 761Vector256<T> end = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 763end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 774Vector256<T> beg = transform.Invoke(Vector256.LoadUnsafe(ref xRef)); 915Vector256<T> beg = transform.Invoke(Vector256.LoadUnsafe(ref xRef)); 916Vector256<T> end = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 918end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 929Vector256<T> beg = transform.Invoke(Vector256.LoadUnsafe(ref xRef)); 1021Vector256<T> beg = transform.Invoke(Vector256.LoadUnsafe(ref xRef)); 1022Vector256<T> end = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 1024end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 1034Vector256<T> beg = transform.Invoke(Vector256.LoadUnsafe(ref xRef)); 1106Vector256<T> beg = transform.Invoke(Vector256.LoadUnsafe(ref xRef)); 1107Vector256<T> end = transform.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 1109end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 1119Vector256<T> beg = transform.Invoke(Vector256.LoadUnsafe(ref xRef)); 1211if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TBinaryOperator.Vectorizable) 1215if (remainder >= (uint)Vector256<T>.Count) 1479Vector256<T> vresult = Vector256.Create(TAggregationOperator.IdentityValue); 1483Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1485Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1486Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 1490if (remainder > (uint)(Vector256<T>.Count * 8)) 1518misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)xPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T); 1523Debug.Assert(((nuint)xPtr % (uint)sizeof(Vector256<T>)) == 0); 1533misalignment = (uint)Vector256<T>.Count; 1541Vector256<T> vector1; 1542Vector256<T> vector2; 1543Vector256<T> vector3; 1544Vector256<T> vector4; 1548while (remainder >= (uint)(Vector256<T>.Count * 8)) 1552vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 1553Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0))); 1554vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 1555Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1))); 1556vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 1557Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2))); 1558vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 1559Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3))); 1568vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 1569Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4))); 1570vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 1571Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5))); 1572vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 1573Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6))); 1574vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 1575Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7))); 1585xPtr += (uint)(Vector256<T>.Count * 8); 1586yPtr += (uint)(Vector256<T>.Count * 8); 1588remainder -= (uint)(Vector256<T>.Count * 8); 1610(nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector256<T>.Count); 1618Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)), 1619Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 7))); 1626Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)), 1627Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 6))); 1634Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)), 1635Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 5))); 1642Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)), 1643Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 4))); 1650Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)), 1651Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 3))); 1658Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)), 1659Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 2))); 1666Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 1)), 1667Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 1))); 1956Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1958Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1959Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 1961end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 1972Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2117Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2119Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2120Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 2122end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 2133Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2229Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2231Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2232Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 2234end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 2244Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2322Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2324Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2325Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 2327end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue)); 2337Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2427private static Vector256<T> CreateAlignmentMaskVector256<T>(int count) 2535private static Vector256<T> CreateRemainderMaskVector256<T>(int count)
System\Numerics\Tensors\netcore\Common\TensorPrimitives.IBinaryOperator.cs (238)
19static abstract Vector256<T> Invoke(Vector256<T> x, Vector256<T> y); 103if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TBinaryOperator.Vectorizable) 105if (remainder >= (uint)Vector256<T>.Count) 402Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 404Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 405Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 407if (remainder > (uint)(Vector256<T>.Count * 8)) 434nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T); 440Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0); 445Vector256<T> vector1; 446Vector256<T> vector2; 447Vector256<T> vector3; 448Vector256<T> vector4; 455while (remainder >= (uint)(Vector256<T>.Count * 8)) 459vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 460Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0))); 461vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 462Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1))); 463vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 464Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2))); 465vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 466Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3))); 468vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0)); 469vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1)); 470vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2)); 471vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3)); 475vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 476Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4))); 477vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 478Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5))); 479vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 480Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6))); 481vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 482Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7))); 484vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4)); 485vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5)); 486vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6)); 487vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7)); 492xPtr += (uint)(Vector256<T>.Count * 8); 493yPtr += (uint)(Vector256<T>.Count * 8); 494dPtr += (uint)(Vector256<T>.Count * 8); 496remainder -= (uint)(Vector256<T>.Count * 8); 501while (remainder >= (uint)(Vector256<T>.Count * 8)) 505vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 506Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0))); 507vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 508Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1))); 509vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 510Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2))); 511vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 512Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3))); 514vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0)); 515vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1)); 516vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2)); 517vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3)); 521vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 522Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4))); 523vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 524Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5))); 525vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 526Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6))); 527vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 528Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7))); 530vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4)); 531vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5)); 532vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6)); 533vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7)); 538xPtr += (uint)(Vector256<T>.Count * 8); 539yPtr += (uint)(Vector256<T>.Count * 8); 540dPtr += (uint)(Vector256<T>.Count * 8); 542remainder -= (uint)(Vector256<T>.Count * 8); 562remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count); 564switch (remainder / (uint)Vector256<T>.Count) 568Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)), 569Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 8))); 570vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8)); 576Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)), 577Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 7))); 578vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7)); 584Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)), 585Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 6))); 586vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6)); 592Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)), 593Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 5))); 594vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5)); 600Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)), 601Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 4))); 602vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4)); 608Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)), 609Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 3))); 610vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3)); 616Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)), 617Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 2))); 618vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2)); 625end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count); 944Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 946Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 947Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 950end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 960Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1116Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1118Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1119Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 1122end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1132Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1231Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1233Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1234Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 1237end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1246Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1321Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1323Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1324Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count)); 1327end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1336Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1435if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TTransformOperator.Vectorizable && TBinaryOperator.Vectorizable) 1437if (remainder >= (uint)Vector256<T>.Count) 1730Vector256<T> yVec = Vector256.Create(y); 1732Vector256<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)), 1734Vector256<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)), 1737if (remainder > (uint)(Vector256<T>.Count * 8)) 1762nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T); 1767Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0); 1772Vector256<T> vector1; 1773Vector256<T> vector2; 1774Vector256<T> vector3; 1775Vector256<T> vector4; 1782while (remainder >= (uint)(Vector256<T>.Count * 8)) 1786vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0))), 1788vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1))), 1790vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2))), 1792vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3))), 1795vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0)); 1796vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1)); 1797vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2)); 1798vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3)); 1802vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4))), 1804vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5))), 1806vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6))), 1808vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7))), 1811vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4)); 1812vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5)); 1813vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6)); 1814vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7)); 1819xPtr += (uint)(Vector256<T>.Count * 8); 1820dPtr += (uint)(Vector256<T>.Count * 8); 1822remainder -= (uint)(Vector256<T>.Count * 8); 1827while (remainder >= (uint)(Vector256<T>.Count * 8)) 1831vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0))), 1833vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1))), 1835vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2))), 1837vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3))), 1840vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0)); 1841vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1)); 1842vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2)); 1843vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3)); 1847vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4))), 1849vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5))), 1851vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6))), 1853vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7))), 1856vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4)); 1857vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5)); 1858vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6)); 1859vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7)); 1864xPtr += (uint)(Vector256<T>.Count * 8); 1865dPtr += (uint)(Vector256<T>.Count * 8); 1867remainder -= (uint)(Vector256<T>.Count * 8); 1886remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count); 1888switch (remainder / (uint)Vector256<T>.Count) 1892Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8))), 1894vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8)); 1900Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7))), 1902vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7)); 1908Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6))), 1910vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6)); 1916Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5))), 1918vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5)); 1924Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4))), 1926vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4)); 1932Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3))), 1934vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3)); 1940Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2))), 1942vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2)); 1949end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count); 2264Vector256<T> yVec = Vector256.Create(y); 2266Vector256<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)), 2268Vector256<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)), 2272end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2282Vector256<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)), 2440Vector256<T> yVec = Vector256.Create(y); 2442Vector256<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)), 2444Vector256<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)), 2448end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2458Vector256<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)), 2559Vector256<T> yVec = Vector256.Create(y); 2561Vector256<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)), 2563Vector256<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)), 2567end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2576Vector256<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)), 2653Vector256<T> yVec = Vector256.Create(y); 2655Vector256<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)), 2657Vector256<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)), 2661end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2670Vector256<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)), 2723private static T HorizontalAggregate<T, TAggregate>(Vector256<T> x) where TAggregate : struct, IBinaryOperator<T> => 2774public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => TOperator.Invoke(y, x);
System\Numerics\Tensors\netcore\Common\TensorPrimitives.IBooleanUnaryOperator.cs (47)
20static abstract Vector256<T> Invoke(Vector256<T> x); 29static abstract bool ShouldEarlyExit(Vector256<T> result); 40public static bool ShouldEarlyExit(Vector256<T> result) => Vector256.AnyWhereAllBitsSet(result); 55public static bool ShouldEarlyExit(Vector256<T> result) => 56typeof(T) == typeof(float) ? Vector256.EqualsAny(result.AsUInt32(), Vector256<uint>.Zero) : 57typeof(T) == typeof(double) ? Vector256.EqualsAny(result.AsUInt64(), Vector256<ulong>.Zero) : 58Vector256.EqualsAny(result, Vector256<T>.Zero); 111if (Vector256.IsHardwareAccelerated && TOperator.Vectorizable && Vector256<T>.IsSupported) 113oneVectorFromEnd = x.Length - Vector256<T>.Count; 124i += Vector256<T>.Count; 130TAnyAll.ShouldEarlyExit(TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count))))) 248if (Vector256.IsHardwareAccelerated && TOperator.Vectorizable && Vector256<T>.IsSupported) 250int vectorFromEnd = x.Length - Vector256<T>.Count; 257i += Vector256<T>.Count; 264i = x.Length - Vector256<T>.Count; 272Vector256<byte> v = TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)i)).AsByte(); 274(v & Vector256<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i); 359if (Vector256.IsHardwareAccelerated && TOperator.Vectorizable && Vector256<T>.IsSupported) 361int vectorsFromEnd = x.Length - (Vector256<T>.Count * sizeof(T)); 368i += Vector256<T>.Count * sizeof(T); 375i = x.Length - (Vector256<T>.Count * sizeof(T)); 383Vector256<byte> v = 386TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + Vector256<T>.Count))).AsUInt16()); 388(v & Vector256<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i); 480if (Vector256.IsHardwareAccelerated && TOperator.Vectorizable && Vector256<T>.IsSupported) 482int vectorsFromEnd = x.Length - (Vector256<T>.Count * sizeof(T)); 489i += Vector256<T>.Count * sizeof(T); 496i = x.Length - (Vector256<T>.Count * sizeof(T)); 504Vector256<byte> v = 508TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + Vector256<T>.Count))).AsUInt32()), 510TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (2 * Vector256<T>.Count)))).AsUInt32(), 511TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (3 * Vector256<T>.Count)))).AsUInt32())); 513(v & Vector256<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i); 617if (Vector256.IsHardwareAccelerated && TOperator.Vectorizable && Vector256<T>.IsSupported) 621int vectorsFromEnd = x.Length - (Vector256<T>.Count * sizeof(T)); 628i += Vector256<T>.Count * sizeof(T); 635i = x.Length - (Vector256<T>.Count * sizeof(T)); 643Vector256<byte> v = 648TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + Vector256<T>.Count))).AsUInt64()), 650TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (2 * Vector256<T>.Count)))).AsUInt64(), 651TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (3 * Vector256<T>.Count)))).AsUInt64())), 654TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (4 * Vector256<T>.Count)))).AsUInt64(), 655TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (5 * Vector256<T>.Count)))).AsUInt64()), 657TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (6 * Vector256<T>.Count)))).AsUInt64(), 658TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)(i + (7 * Vector256<T>.Count)))).AsUInt64()))); 660(v & Vector256<byte>.One).StoreUnsafe(ref Unsafe.As<bool, byte>(ref destinationRef), (uint)i);
System\Numerics\Tensors\netcore\Common\TensorPrimitives.IIndexOfMinMaxOperator.cs (83)
15static abstract T Aggregate(Vector256<T> value); 19static abstract Vector256<T> Compare(Vector256<T> x, Vector256<T> y); 39if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 324Vector256<T> result = Vector256.Create(x); 327Vector256<T> nanMask = Vector256.IsNaN(result); 328if (nanMask != Vector256<T>.Zero) 335Vector256<TInt> indexIncrement = Vector256.Create(TInt.CreateTruncating(Vector256<TInt>.Count)); 336Vector256<TInt> resultIndex = Vector256<TInt>.Indices; 337Vector256<TInt> currentIndex = resultIndex + indexIncrement; 338ReadOnlySpan<T> span = x.Slice(Vector256<T>.Count); 342Vector256<T> current; 343if (span.Length >= Vector256<T>.Count) 346span = span.Slice(Vector256<T>.Count); 351int start = x.Length - Vector256<T>.Count; 353currentIndex = Vector256.Create(TInt.CreateTruncating(start)) + Vector256<TInt>.Indices; 360Vector256<T> nanMask = Vector256.IsNaN(current); 361if (nanMask != Vector256<T>.Zero) 368Vector256<T> mask = TOperator.Compare(current, result); 379Vector256<TInt> aggMask = ~Vector256.Equals(result.As<T, TInt>(), Vector256.Create(aggResult).As<T, TInt>()); 380Vector256<TInt> aggIndex = resultIndex | aggMask; 391Vector256<T> result = Vector256.Create(x); 394Vector256<T> nanMask = Vector256.IsNaN(result); 395if (nanMask != Vector256<T>.Zero) 402Vector256<uint> indexIncrement = Vector256.Create((uint)Vector256<uint>.Count); 403Vector256<uint> resultIndex1 = Vector256<uint>.Indices; 404Vector256<uint> resultIndex2 = resultIndex1 + indexIncrement; 405Vector256<uint> currentIndex = resultIndex2 + indexIncrement; 406ReadOnlySpan<T> span = x.Slice(Vector256<T>.Count); 410Vector256<T> current; 411if (span.Length >= Vector256<T>.Count) 414span = span.Slice(Vector256<T>.Count); 419int start = x.Length - Vector256<T>.Count; 421currentIndex = Vector256.Create((uint)start) + Vector256<uint>.Indices; 428Vector256<T> nanMask = Vector256.IsNaN(current); 429if (nanMask != Vector256<T>.Zero) 436Vector256<T> mask = TOperator.Compare(current, result); 437(Vector256<int> mask1, Vector256<int> mask2) = Vector256.Widen(mask.AsInt16()); 450Vector256<short> aggMask = ~Vector256.Equals(result.AsInt16(), Vector256.Create(aggResult).AsInt16()); 452(Vector256<int> mask1, Vector256<int> mask2) = Vector256.Widen(aggMask); 453Vector256<uint> aggIndex = resultIndex1 | mask1.AsUInt32(); 466Vector256<T> result = Vector256.Create(x); 469Vector256<T> nanMask = Vector256.IsNaN(result); 470if (nanMask != Vector256<T>.Zero) 477Vector256<uint> indexIncrement = Vector256.Create((uint)Vector256<uint>.Count); 478Vector256<uint> resultIndex1 = Vector256<uint>.Indices; 479Vector256<uint> resultIndex2 = resultIndex1 + indexIncrement; 480Vector256<uint> resultIndex3 = resultIndex2 + indexIncrement; 481Vector256<uint> resultIndex4 = resultIndex3 + indexIncrement; 482Vector256<uint> currentIndex = resultIndex4 + indexIncrement; 483ReadOnlySpan<T> span = x.Slice(Vector256<T>.Count); 487Vector256<T> current; 488if (span.Length >= Vector256<T>.Count) 491span = span.Slice(Vector256<T>.Count); 496int start = x.Length - Vector256<T>.Count; 498currentIndex = Vector256.Create((uint)start) + Vector256<uint>.Indices; 505Vector256<T> nanMask = Vector256.IsNaN(current); 506if (nanMask != Vector256<T>.Zero) 513Vector256<T> mask = TOperator.Compare(current, result); 514(Vector256<short> lowerMask, Vector256<short> upperMask) = Vector256.Widen(mask.AsSByte()); 515(Vector256<int> mask1, Vector256<int> mask2) = Vector256.Widen(lowerMask); 516(Vector256<int> mask3, Vector256<int> mask4) = Vector256.Widen(upperMask); 533Vector256<sbyte> aggMask = ~Vector256.Equals(result.AsSByte(), Vector256.Create(aggResult).AsSByte()); 535(Vector256<short> lowerMask, Vector256<short> upperMask) = Vector256.Widen(aggMask); 536(Vector256<int> mask1, Vector256<int> mask2) = Vector256.Widen(lowerMask); 537(Vector256<int> mask3, Vector256<int> mask4) = Vector256.Widen(upperMask); 538Vector256<uint> aggIndex = resultIndex1 | mask1.AsUInt32();
System\Numerics\Tensors\netcore\Common\TensorPrimitives.IStatefulUnaryOperator.cs (100)
19Vector256<T> Invoke(Vector256<T> x); 69if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TStatefulUnaryOperator.Vectorizable) 71if (remainder >= (uint)Vector256<T>.Count) 336Vector256<T> beg = op.Invoke(Vector256.LoadUnsafe(ref xRef)); 337Vector256<T> end = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 339if (remainder > (uint)(Vector256<T>.Count * 8)) 364nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T); 369Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0); 374Vector256<T> vector1; 375Vector256<T> vector2; 376Vector256<T> vector3; 377Vector256<T> vector4; 384while (remainder >= (uint)(Vector256<T>.Count * 8)) 388vector1 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0))); 389vector2 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1))); 390vector3 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2))); 391vector4 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3))); 393vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0)); 394vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1)); 395vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2)); 396vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3)); 400vector1 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4))); 401vector2 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5))); 402vector3 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6))); 403vector4 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7))); 405vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4)); 406vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5)); 407vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6)); 408vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7)); 413xPtr += (uint)(Vector256<T>.Count * 8); 414dPtr += (uint)(Vector256<T>.Count * 8); 416remainder -= (uint)(Vector256<T>.Count * 8); 421while (remainder >= (uint)(Vector256<T>.Count * 8)) 425vector1 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0))); 426vector2 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1))); 427vector3 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2))); 428vector4 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3))); 430vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0)); 431vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1)); 432vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2)); 433vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3)); 437vector1 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4))); 438vector2 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5))); 439vector3 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6))); 440vector4 = op.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7))); 442vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4)); 443vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5)); 444vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6)); 445vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7)); 450xPtr += (uint)(Vector256<T>.Count * 8); 451dPtr += (uint)(Vector256<T>.Count * 8); 453remainder -= (uint)(Vector256<T>.Count * 8); 472remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count); 474switch (remainder / (uint)Vector256<T>.Count) 478Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8))); 479vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8)); 485Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7))); 486vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7)); 492Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6))); 493vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6)); 499Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5))); 500vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5)); 506Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4))); 507vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4)); 513Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3))); 514vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3)); 520Vector256<T> vector = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2))); 521vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2)); 528end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count); 816Vector256<T> beg = op.Invoke(Vector256.LoadUnsafe(ref xRef)); 817Vector256<T> end = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 820end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 830Vector256<T> beg = op.Invoke(Vector256.LoadUnsafe(ref xRef)); 968Vector256<T> beg = op.Invoke(Vector256.LoadUnsafe(ref xRef)); 969Vector256<T> end = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 972end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 982Vector256<T> beg = op.Invoke(Vector256.LoadUnsafe(ref xRef)); 1071Vector256<T> beg = op.Invoke(Vector256.LoadUnsafe(ref xRef)); 1072Vector256<T> end = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 1075end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1084Vector256<T> beg = op.Invoke(Vector256.LoadUnsafe(ref xRef)); 1153Vector256<T> beg = op.Invoke(Vector256.LoadUnsafe(ref xRef)); 1154Vector256<T> end = op.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)); 1157end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1166Vector256<T> beg = op.Invoke(Vector256.LoadUnsafe(ref xRef));
System\Numerics\Tensors\netcore\Common\TensorPrimitives.ITernaryOperator.cs (407)
19static abstract Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> z); 29public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> z) => TOperator.Invoke(x, z, y); 90if (TTernaryOperator.Vectorizable && Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported) 92if (remainder >= (uint)Vector256<T>.Count) 421Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 424Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 425Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 426Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count)); 428if (remainder > (uint)(Vector256<T>.Count * 8)) 457nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (nuint)sizeof(T); 464Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0); 469Vector256<T> vector1; 470Vector256<T> vector2; 471Vector256<T> vector3; 472Vector256<T> vector4; 479while (remainder >= (uint)(Vector256<T>.Count * 8)) 483vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 484Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)), 485Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 0))); 486vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 487Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)), 488Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 1))); 489vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 490Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)), 491Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 2))); 492vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 493Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)), 494Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 3))); 496vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0)); 497vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1)); 498vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2)); 499vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3)); 503vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 504Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)), 505Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 4))); 506vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 507Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)), 508Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 5))); 509vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 510Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)), 511Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 6))); 512vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 513Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)), 514Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 7))); 516vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4)); 517vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5)); 518vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6)); 519vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7)); 524xPtr += (uint)(Vector256<T>.Count * 8); 525yPtr += (uint)(Vector256<T>.Count * 8); 526zPtr += (uint)(Vector256<T>.Count * 8); 527dPtr += (uint)(Vector256<T>.Count * 8); 529remainder -= (uint)(Vector256<T>.Count * 8); 534while (remainder >= (uint)(Vector256<T>.Count * 8)) 538vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 539Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)), 540Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 0))); 541vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 542Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)), 543Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 1))); 544vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 545Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)), 546Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 2))); 547vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 548Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)), 549Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 3))); 551vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0)); 552vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1)); 553vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2)); 554vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3)); 558vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 559Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)), 560Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 4))); 561vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 562Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)), 563Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 5))); 564vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 565Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)), 566Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 6))); 567vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 568Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)), 569Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 7))); 571vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4)); 572vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5)); 573vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6)); 574vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7)); 579xPtr += (uint)(Vector256<T>.Count * 8); 580yPtr += (uint)(Vector256<T>.Count * 8); 581zPtr += (uint)(Vector256<T>.Count * 8); 582dPtr += (uint)(Vector256<T>.Count * 8); 584remainder -= (uint)(Vector256<T>.Count * 8); 605remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count); 607switch (remainder / (uint)Vector256<T>.Count) 611Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)), 612Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 8)), 613Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 8))); 614vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8)); 620Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)), 621Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 7)), 622Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 7))); 623vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7)); 629Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)), 630Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 6)), 631Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 6))); 632vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6)); 638Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)), 639Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 5)), 640Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 5))); 641vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5)); 647Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)), 648Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 4)), 649Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 4))); 650vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4)); 656Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)), 657Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 3)), 658Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 3))); 659vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3)); 665Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)), 666Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 2)), 667Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 2))); 668vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2)); 675end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count); 1025Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1028Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1029Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 1030Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count)); 1033end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1043Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1217Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1220Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1221Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 1222Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count)); 1225end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1235Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1344Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1347Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1348Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 1349Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count)); 1352end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1361Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1442Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1445Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1446Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 1447Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count)); 1450end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 1459Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1565if (TTernaryOperator.Vectorizable && Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported) 1567if (remainder >= (uint)Vector256<T>.Count) 1892Vector256<T> zVec = Vector256.Create(z); 1894Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 1897Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 1898Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 1901if (remainder > (uint)(Vector256<T>.Count * 8)) 1928nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T); 1934Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0); 1939Vector256<T> vector1; 1940Vector256<T> vector2; 1941Vector256<T> vector3; 1942Vector256<T> vector4; 1949while (remainder >= (uint)(Vector256<T>.Count * 8)) 1953vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 1954Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)), 1956vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 1957Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)), 1959vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 1960Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)), 1962vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 1963Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)), 1966vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0)); 1967vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1)); 1968vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2)); 1969vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3)); 1973vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 1974Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)), 1976vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 1977Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)), 1979vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 1980Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)), 1982vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 1983Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)), 1986vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4)); 1987vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5)); 1988vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6)); 1989vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7)); 1994xPtr += (uint)(Vector256<T>.Count * 8); 1995yPtr += (uint)(Vector256<T>.Count * 8); 1996dPtr += (uint)(Vector256<T>.Count * 8); 1998remainder -= (uint)(Vector256<T>.Count * 8); 2003while (remainder >= (uint)(Vector256<T>.Count * 8)) 2007vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 2008Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)), 2010vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 2011Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)), 2013vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 2014Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)), 2016vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 2017Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)), 2020vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0)); 2021vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1)); 2022vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2)); 2023vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3)); 2027vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 2028Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)), 2030vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 2031Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)), 2033vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 2034Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)), 2036vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 2037Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)), 2040vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4)); 2041vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5)); 2042vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6)); 2043vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7)); 2048xPtr += (uint)(Vector256<T>.Count * 8); 2049yPtr += (uint)(Vector256<T>.Count * 8); 2050dPtr += (uint)(Vector256<T>.Count * 8); 2052remainder -= (uint)(Vector256<T>.Count * 8); 2072remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count); 2074switch (remainder / (uint)Vector256<T>.Count) 2078Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)), 2079Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 8)), 2081vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8)); 2087Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)), 2088Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 7)), 2090vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7)); 2096Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)), 2097Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 6)), 2099vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6)); 2105Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)), 2106Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 5)), 2108vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5)); 2114Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)), 2115Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 4)), 2117vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4)); 2123Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)), 2124Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 3)), 2126vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3)); 2132Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)), 2133Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 2)), 2135vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2)); 2142end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count); 2488Vector256<T> zVec = Vector256.Create(z); 2490Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2493Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2494Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 2498end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2508Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2684Vector256<T> zVec = Vector256.Create(z); 2686Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2689Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2690Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 2694end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2704Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2815Vector256<T> zVec = Vector256.Create(z); 2817Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2820Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2821Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 2825end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2834Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2917Vector256<T> zVec = Vector256.Create(z); 2919Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 2922Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 2923Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count), 2927end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 2936Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 3051if (TTernaryOperator.Vectorizable && Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported) 3053if (remainder >= (uint)Vector256<T>.Count) 3373Vector256<T> yVec = Vector256.Create(y); 3374Vector256<T> zVec = Vector256.Create(z); 3376Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 3379Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 3383if (remainder > (uint)(Vector256<T>.Count * 8)) 3408nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T); 3413Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0); 3418Vector256<T> vector1; 3419Vector256<T> vector2; 3420Vector256<T> vector3; 3421Vector256<T> vector4; 3428while (remainder >= (uint)(Vector256<T>.Count * 8)) 3432vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 3435vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 3438vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 3441vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 3445vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0)); 3446vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1)); 3447vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2)); 3448vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3)); 3452vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 3455vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 3458vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 3461vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 3465vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4)); 3466vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5)); 3467vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6)); 3468vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7)); 3473xPtr += (uint)(Vector256<T>.Count * 8); 3474dPtr += (uint)(Vector256<T>.Count * 8); 3476remainder -= (uint)(Vector256<T>.Count * 8); 3481while (remainder >= (uint)(Vector256<T>.Count * 8)) 3485vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)), 3488vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)), 3491vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)), 3494vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)), 3498vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0)); 3499vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1)); 3500vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2)); 3501vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3)); 3505vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)), 3508vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)), 3511vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)), 3514vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)), 3518vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4)); 3519vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5)); 3520vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6)); 3521vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7)); 3526xPtr += (uint)(Vector256<T>.Count * 8); 3527dPtr += (uint)(Vector256<T>.Count * 8); 3529remainder -= (uint)(Vector256<T>.Count * 8); 3548remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count); 3550switch (remainder / (uint)Vector256<T>.Count) 3554Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)), 3557vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8)); 3563Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)), 3566vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7)); 3572Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)), 3575vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6)); 3581Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)), 3584vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5)); 3590Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)), 3593vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4)); 3599Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)), 3602vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3)); 3608Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)), 3611vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2)); 3618end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count); 3959Vector256<T> yVec = Vector256.Create(y); 3960Vector256<T> zVec = Vector256.Create(z); 3962Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 3965Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 3970end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 3980Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 4157Vector256<T> yVec = Vector256.Create(y); 4158Vector256<T> zVec = Vector256.Create(z); 4160Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 4163Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 4168end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 4178Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 4290Vector256<T> yVec = Vector256.Create(y); 4291Vector256<T> zVec = Vector256.Create(z); 4293Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 4296Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 4301end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 4310Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 4394Vector256<T> yVec = Vector256.Create(y); 4395Vector256<T> zVec = Vector256.Create(z); 4397Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef), 4400Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count), 4405end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count); 4414Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryInputBinaryOutput.cs (40)
18static abstract (Vector256<T> First, Vector256<T> Second) Invoke(Vector256<T> x); 28static abstract (Vector256<T> First, Vector256<T> Second) Invoke(Vector256<T> x, Vector256<T> y); 39public static (Vector256<T> First, Vector256<T> Second) Invoke(Vector256<T> x, Vector256<T> y) => TOperator.Invoke(y, x); 100if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TUnaryOperator.Vectorizable) 102oneVectorFromEnd = x.Length - Vector256<T>.Count; 108(Vector256<T> first, Vector256<T> second) = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref sourceRef, (uint)i)); 112i += Vector256<T>.Count; 119i = x.Length - Vector256<T>.Count; 121(Vector256<T> first, Vector256<T> second) = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref sourceRef, (uint)i)); 253if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TOperator.Vectorizable) 255oneVectorFromEnd = x.Length - Vector256<T>.Count; 261(Vector256<T> first, Vector256<T> second) = TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)i), Vector256.LoadUnsafe(ref yRef, (uint)i)); 265i += Vector256<T>.Count; 272Vector256<T> mask = Vector256.Equals(CreateRemainderMaskVector256<T>(x.Length - i), Vector256<T>.Zero); 274i = x.Length - Vector256<T>.Count; 276Vector256<T> first = Vector256.ConditionalSelect(mask, 280Vector256<T> second = Vector256.ConditionalSelect(mask, 436if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TOperator.Vectorizable) 438oneVectorFromEnd = x.Length - Vector256<T>.Count; 441Vector256<T> yVec = Vector256.Create(y); 446(Vector256<T> first, Vector256<T> second) = TOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)i), yVec); 450i += Vector256<T>.Count; 457Vector256<T> mask = Vector256.Equals(CreateRemainderMaskVector256<T>(x.Length - i), Vector256<T>.Zero); 459i = x.Length - Vector256<T>.Count; 461Vector256<T> first = Vector256.ConditionalSelect(mask, 465Vector256<T> second = Vector256.ConditionalSelect(mask,
System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryOneToFourOperator.cs (24)
20static abstract (Vector256<TOutput>, Vector256<TOutput>, Vector256<TOutput>, Vector256<TOutput>) Invoke(Vector256<TInput> x); 83Debug.Assert(Vector256<TInput>.IsSupported); 84Debug.Assert(Vector256<TOutput>.IsSupported); 86oneVectorFromEnd = x.Length - Vector256<TInput>.Count; 92(Vector256<TOutput>, Vector256<TOutput>, Vector256<TOutput>, Vector256<TOutput>) results = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref sourceRef, (uint)i)); 94results.Item2.StoreUnsafe(ref destinationRef, (uint)(i + Vector256<TOutput>.Count)); 95results.Item3.StoreUnsafe(ref destinationRef, (uint)(i + (Vector256<TOutput>.Count * 2))); 96results.Item4.StoreUnsafe(ref destinationRef, (uint)(i + (Vector256<TOutput>.Count * 3))); 98i += Vector256<TInput>.Count; 105i = x.Length - Vector256<TInput>.Count; 107(Vector256<TOutput>, Vector256<TOutput>, Vector256<TOutput>, Vector256<TOutput>) results = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref sourceRef, (uint)i)); 109results.Item2.StoreUnsafe(ref destinationRef, (uint)(i + Vector256<TOutput>.Count)); 110results.Item3.StoreUnsafe(ref destinationRef, (uint)(i + (Vector256<TOutput>.Count * 2))); 111results.Item4.StoreUnsafe(ref destinationRef, (uint)(i + (Vector256<TOutput>.Count * 3)));
System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryOneToTwoOperator.cs (14)
20static abstract (Vector256<TOutput> Lower, Vector256<TOutput> Upper) Invoke(Vector256<TInput> x); 79Debug.Assert(Vector256<TInput>.IsSupported); 80Debug.Assert(Vector256<TOutput>.IsSupported); 82oneVectorFromEnd = x.Length - Vector256<TInput>.Count; 88(Vector256<TOutput> lower, Vector256<TOutput> upper) = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref sourceRef, (uint)i)); 90upper.StoreUnsafe(ref destinationRef, (uint)(i + Vector256<TOutput>.Count)); 92i += Vector256<TInput>.Count; 99i = x.Length - Vector256<TInput>.Count; 101(Vector256<TOutput> lower, Vector256<TOutput> upper) = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref sourceRef, (uint)i)); 103upper.StoreUnsafe(ref destinationRef, (uint)(i + Vector256<TOutput>.Count));
System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryOperator.cs (103)
36static abstract Vector256<TOutput> Invoke(Vector256<TInput> x); 46public static Vector256<T> Invoke(Vector256<T> x) => x; 109if (Vector256.IsHardwareAccelerated && Vector256<TInput>.IsSupported && Vector256<TOutput>.IsSupported && TUnaryOperator.Vectorizable && sizeof(TInput) == sizeof(TOutput)) 111if (remainder >= (uint)Vector256<TInput>.Count) 376Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef)); 377Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count)); 379if (remainder > (uint)(Vector256<TInput>.Count * 8)) 404nuint misalignment = ((uint)sizeof(Vector256<TInput>) - ((nuint)dPtr % (uint)sizeof(Vector256<TInput>))) / (uint)sizeof(TInput); 409Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<TInput>)) == 0); 414Vector256<TOutput> vector1; 415Vector256<TOutput> vector2; 416Vector256<TOutput> vector3; 417Vector256<TOutput> vector4; 424while (remainder >= (uint)(Vector256<TInput>.Count * 8)) 428vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 0))); 429vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 1))); 430vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 2))); 431vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 3))); 433vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 0)); 434vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 1)); 435vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 2)); 436vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 3)); 440vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 4))); 441vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 5))); 442vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 6))); 443vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 7))); 445vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 4)); 446vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 5)); 447vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 6)); 448vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 7)); 453xPtr += (uint)(Vector256<TInput>.Count * 8); 454dPtr += (uint)(Vector256<TOutput>.Count * 8); 456remainder -= (uint)(Vector256<TInput>.Count * 8); 461while (remainder >= (uint)(Vector256<TInput>.Count * 8)) 465vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 0))); 466vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 1))); 467vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 2))); 468vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 3))); 470vector1.Store(dPtr + (uint)(Vector256<TOutput>.Count * 0)); 471vector2.Store(dPtr + (uint)(Vector256<TOutput>.Count * 1)); 472vector3.Store(dPtr + (uint)(Vector256<TOutput>.Count * 2)); 473vector4.Store(dPtr + (uint)(Vector256<TOutput>.Count * 3)); 477vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 4))); 478vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 5))); 479vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 6))); 480vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 7))); 482vector1.Store(dPtr + (uint)(Vector256<TOutput>.Count * 4)); 483vector2.Store(dPtr + (uint)(Vector256<TOutput>.Count * 5)); 484vector3.Store(dPtr + (uint)(Vector256<TOutput>.Count * 6)); 485vector4.Store(dPtr + (uint)(Vector256<TOutput>.Count * 7)); 490xPtr += (uint)(Vector256<TInput>.Count * 8); 491dPtr += (uint)(Vector256<TOutput>.Count * 8); 493remainder -= (uint)(Vector256<TInput>.Count * 8); 512remainder = (remainder + (uint)(Vector256<TInput>.Count - 1)) & (nuint)(-Vector256<TInput>.Count); 514switch (remainder / (uint)Vector256<TInput>.Count) 518Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 8))); 519vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 8)); 525Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 7))); 526vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 7)); 532Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 6))); 533vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 6)); 539Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 5))); 540vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 5)); 546Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 4))); 547vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 4)); 553Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 3))); 554vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 3)); 560Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 2))); 561vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 2)); 568end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<TOutput>.Count); 856Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef)); 857Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count)); 860end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<TOutput>.Count); 870Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef)); 1008Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef)); 1009Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count)); 1012end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<TOutput>.Count); 1022Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef)); 1111Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef)); 1112Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count)); 1115end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<TOutput>.Count); 1124Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef)); 1193Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef)); 1194Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count)); 1197end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<TOutput>.Count); 1206Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryTwoToOneOperator.cs (10)
20static abstract Vector256<TOutput> Invoke(Vector256<TInput> lower, Vector256<TInput> upper); 79Debug.Assert(Vector256<TInput>.IsSupported); 80Debug.Assert(Vector256<TOutput>.IsSupported); 82twoVectorsFromEnd = x.Length - (Vector256<TInput>.Count * 2); 90Vector256.LoadUnsafe(ref xRef, (uint)(i + Vector256<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i); 92i += Vector256<TInput>.Count * 2; 99i = x.Length - (Vector256<TInput>.Count * 2); 103Vector256.LoadUnsafe(ref xRef, (uint)(i + Vector256<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i);
System\Numerics\Tensors\netcore\TensorPrimitives.Abs.cs (6)
70public static Vector256<T> Invoke(Vector256<T> x) 81Vector256<T> abs = Vector256.ConditionalSelect(Vector256.LessThan(x, Vector256<T>.Zero), -x, x); 82if (Vector256.LessThan(abs, Vector256<T>.Zero) != Vector256<T>.Zero)
System\Numerics\Tensors\netcore\TensorPrimitives.Acos.cs (2)
35public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.Acosh.cs (2)
35public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.AcosPi.cs (2)
35public static Vector256<T> Invoke(Vector256<T> x) => AcosOperator<T>.Invoke(x) / Vector256.Create(T.Pi);
System\Numerics\Tensors\netcore\TensorPrimitives.Add.cs (4)
69public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x + y; 73public static T Invoke(Vector256<T> x) => Vector256.Sum(x);
System\Numerics\Tensors\netcore\TensorPrimitives.AddMultiply.cs (4)
101public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> z) => (x + y) * z;
System\Numerics\Tensors\netcore\TensorPrimitives.Asin.cs (2)
59public static Vector256<T> Invoke(Vector256<T> x)
System\Numerics\Tensors\netcore\TensorPrimitives.Asinh.cs (2)
35public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.AsinPi.cs (2)
35public static Vector256<T> Invoke(Vector256<T> x) => AsinOperator<T>.Invoke(x) / Vector256.Create(T.Pi);
System\Numerics\Tensors\netcore\TensorPrimitives.Atan.cs (2)
35public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.Atan2.cs (3)
76public static Vector256<T> Invoke(Vector256<T> y, Vector256<T> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.Atan2Pi.cs (3)
76public static Vector256<T> Invoke(Vector256<T> y, Vector256<T> x) => Atan2Operator<T>.Invoke(y, x) / Vector256.Create(T.Pi);
System\Numerics\Tensors\netcore\TensorPrimitives.Atanh.cs (2)
35public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.AtanPi.cs (2)
35public static Vector256<T> Invoke(Vector256<T> x) => AtanOperator<T>.Invoke(x) / Vector256.Create(T.Pi);
System\Numerics\Tensors\netcore\TensorPrimitives.BitDecrement.cs (34)
93public static Vector256<T> Invoke(Vector256<T> x) 97Vector256<float> xFloat = x.AsSingle(); 98Vector256<uint> bits = xFloat.AsUInt32(); 101Vector256<uint> result = Vector256.ConditionalSelect( 103bits + Vector256<uint>.One, 104bits - Vector256<uint>.One); 107Vector256<uint> isPositiveZero = Vector256.IsZero(xFloat).AsUInt32(); 108Vector256<uint> specialValue = Vector256.Create(BitConverter.SingleToUInt32Bits(-float.Epsilon)) & isPositiveZero; 110Vector256<uint> isNaNOrNegInf = (Vector256.IsNaN(xFloat) | Vector256.IsNegativeInfinity(xFloat)).AsUInt32(); 113Vector256<uint> specialMask = isPositiveZero | isNaNOrNegInf; 119Vector256<double> xDouble = x.AsDouble(); 120Vector256<ulong> bits = xDouble.AsUInt64(); 123Vector256<ulong> result = Vector256.ConditionalSelect( 125bits + Vector256<ulong>.One, 126bits - Vector256<ulong>.One); 129Vector256<ulong> isPositiveZero = Vector256.IsZero(xDouble).AsUInt64(); 130Vector256<ulong> specialValue = Vector256.Create(BitConverter.DoubleToUInt64Bits(-double.Epsilon)) & isPositiveZero; 132Vector256<ulong> isNaNOrNegInf = (Vector256.IsNaN(xDouble) | Vector256.IsNegativeInfinity(xDouble)).AsUInt64(); 135Vector256<ulong> specialMask = isPositiveZero | isNaNOrNegInf; 236public static Vector256<short> Invoke(Vector256<short> x) 238Vector256<ushort> bits = x.AsUInt16(); 241Vector256<ushort> isNegative = Vector256.IsNegative(x).AsUInt16(); 242Vector256<ushort> result = Vector256.ConditionalSelect( 244bits + Vector256<ushort>.One, 245bits - Vector256<ushort>.One); 248Vector256<ushort> isPositiveZero = Vector256.IsZero(bits); 249Vector256<ushort> specialValue = Vector256.Create(NegativeEpsilonBits) & isPositiveZero; 253Vector256<ushort> absValue = bits & Vector256.Create((ushort)0x7FFF); 254Vector256<ushort> isNaN = Vector256.GreaterThan(absValue, Vector256.Create(PositiveInfinityBits)); 255Vector256<ushort> isNegInf = Vector256.Equals(bits, Vector256.Create(NegativeInfinityBits)); 256Vector256<ushort> isNaNOrNegInf = isNaN | isNegInf; 259Vector256<ushort> specialMask = isPositiveZero | isNaNOrNegInf;
System\Numerics\Tensors\netcore\TensorPrimitives.BitIncrement.cs (34)
93public static Vector256<T> Invoke(Vector256<T> x) 97Vector256<float> xFloat = x.AsSingle(); 98Vector256<uint> bits = xFloat.AsUInt32(); 101Vector256<uint> result = Vector256.ConditionalSelect( 103bits - Vector256<uint>.One, 104bits + Vector256<uint>.One); 107Vector256<uint> isNegativeZero = Vector256.Equals(bits, Vector256.Create(0x8000_0000u)); 108Vector256<uint> specialValue = Vector256.Create(0x0000_0001u) & isNegativeZero; 110Vector256<uint> isNaNOrPosInf = (Vector256.IsNaN(xFloat) | Vector256.IsPositiveInfinity(xFloat)).AsUInt32(); 113Vector256<uint> specialMask = isNegativeZero | isNaNOrPosInf; 119Vector256<double> xDouble = x.AsDouble(); 120Vector256<ulong> bits = xDouble.AsUInt64(); 123Vector256<ulong> result = Vector256.ConditionalSelect( 125bits - Vector256<ulong>.One, 126bits + Vector256<ulong>.One); 129Vector256<ulong> isNegativeZero = Vector256.Equals(bits, Vector256.Create(0x8000_0000_0000_0000ul)); 130Vector256<ulong> specialValue = Vector256.Create(0x0000_0000_0000_0001ul) & isNegativeZero; 132Vector256<ulong> isNaNOrPosInf = (Vector256.IsNaN(xDouble) | Vector256.IsPositiveInfinity(xDouble)).AsUInt64(); 135Vector256<ulong> specialMask = isNegativeZero | isNaNOrPosInf; 236public static Vector256<short> Invoke(Vector256<short> x) 238Vector256<ushort> bits = x.AsUInt16(); 241Vector256<ushort> isNegative = Vector256.IsNegative(x).AsUInt16(); 242Vector256<ushort> result = Vector256.ConditionalSelect( 244bits - Vector256<ushort>.One, 245bits + Vector256<ushort>.One); 248Vector256<ushort> isNegativeZero = Vector256.Equals(bits, Vector256.Create(NegativeZeroBits)); 249Vector256<ushort> specialValue = Vector256.Create(EpsilonBits) & isNegativeZero; 253Vector256<ushort> absValue = bits & Vector256.Create((ushort)0x7FFF); 254Vector256<ushort> isNaN = Vector256.GreaterThan(absValue, Vector256.Create(PositiveInfinityBits)); 255Vector256<ushort> isPosInf = Vector256.Equals(bits, Vector256.Create(PositiveInfinityBits)); 256Vector256<ushort> isNaNOrPosInf = isNaN | isPosInf; 259Vector256<ushort> specialMask = isNegativeZero | isNaNOrPosInf;
System\Numerics\Tensors\netcore\TensorPrimitives.BitwiseAnd.cs (3)
62public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x & y;
System\Numerics\Tensors\netcore\TensorPrimitives.BitwiseOr.cs (3)
62public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x | y;
System\Numerics\Tensors\netcore\TensorPrimitives.Cbrt.cs (2)
46public static Vector256<T> Invoke(Vector256<T> x)
System\Numerics\Tensors\netcore\TensorPrimitives.Ceiling.cs (2)
51public static Vector256<T> Invoke(Vector256<T> x)
System\Numerics\Tensors\netcore\TensorPrimitives.Clamp.cs (12)
223public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> min, Vector256<T> max) => Vector256.Clamp(x, min, max); 236public static Vector256<T> Invoke(Vector256<T> min, Vector256<T> max, Vector256<T> x) => Vector256.Clamp(x, min, max); 249public static Vector256<T> Invoke(Vector256<T> max, Vector256<T> x, Vector256<T> min) => Vector256.Clamp(x, min, max);
System\Numerics\Tensors\netcore\TensorPrimitives.ConvertChecked.cs (2)
39public static Vector256<TTo> Invoke(Vector256<TFrom> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.ConvertHelpers.cs (77)
169public static Vector256<float> Invoke(Vector256<int> x) => Vector256.ConvertToSingle(x); 180public static Vector256<float> Invoke(Vector256<uint> x) => Vector256.ConvertToSingle(x); 191public static Vector256<double> Invoke(Vector256<ulong> x) => Vector256.ConvertToDouble(x); 202public static Vector256<double> Invoke(Vector256<long> x) => Vector256.ConvertToDouble(x); 213public static (Vector256<double> Lower, Vector256<double> Upper) Invoke(Vector256<float> x) => Vector256.Widen(x); 224public static Vector256<float> Invoke(Vector256<double> lower, Vector256<double> upper) => Vector256.Narrow(lower, upper); 235public static (Vector256<ushort> Lower, Vector256<ushort> Upper) Invoke(Vector256<byte> x) => Vector256.Widen(x); 256public static (Vector256<uint>, Vector256<uint>, Vector256<uint>, Vector256<uint>) Invoke(Vector256<byte> x) 258(Vector256<ushort> Lower, Vector256<ushort> Upper) ushorts = Vector256.Widen(x); 259(Vector256<uint> Lower, Vector256<uint> Upper) uintsLower = Vector256.Widen(ushorts.Lower); 260(Vector256<uint> Lower, Vector256<uint> Upper) uintsUpper = Vector256.Widen(ushorts.Upper); 294public static (Vector256<float>, Vector256<float>, Vector256<float>, Vector256<float>) Invoke(Vector256<byte> x) 325public static (Vector256<short> Lower, Vector256<short> Upper) Invoke(Vector256<sbyte> x) => Vector256.Widen(x); 336public static (Vector256<uint> Lower, Vector256<uint> Upper) Invoke(Vector256<ushort> x) => Vector256.Widen(x); 347public static (Vector256<int> Lower, Vector256<int> Upper) Invoke(Vector256<short> x) => Vector256.Widen(x); 358public static (Vector256<ulong> Lower, Vector256<ulong> Upper) Invoke(Vector256<uint> x) => Vector256.Widen(x); 369public static (Vector256<long> Lower, Vector256<long> Upper) Invoke(Vector256<int> x) => Vector256.Widen(x); 444public static (Vector256<float> Lower, Vector256<float> Upper) Invoke(Vector256<short> x) 446(Vector256<int> lowerInt32, Vector256<int> upperInt32) = Vector256.Widen(x); 451static Vector256<float> HalfAsWidenedUInt32ToSingle(Vector256<uint> value) 454Vector256<uint> sign = value & Vector256.Create(SingleSignMask); 457Vector256<uint> bitValueInProcess = value; 460Vector256<uint> offsetExponent = bitValueInProcess & Vector256.Create(HalfExponentMask); 463Vector256<uint> subnormalMask = Vector256.Equals(offsetExponent, Vector256<uint>.Zero); 466Vector256<uint> infinityOrNaNMask = Vector256.Equals(offsetExponent, Vector256.Create(HalfExponentMask)); 469Vector256<uint> maskedExponentLowerBound = subnormalMask & Vector256.Create(ExponentLowerBound); 472Vector256<uint> offsetMaskedExponentLowerBound = Vector256.Create(ExponentOffset) | maskedExponentLowerBound; 478offsetMaskedExponentLowerBound = Vector256.ConditionalSelect(Vector256.Equals(infinityOrNaNMask, Vector256<uint>.Zero), 489Vector256<uint> absoluteValue = (bitValueInProcess.AsSingle() - maskedExponentLowerBound.AsSingle()).AsUInt32(); 637public static Vector256<ushort> Invoke(Vector256<float> lower, Vector256<float> upper) 643static Vector256<uint> SingleToHalfAsWidenedUInt32(Vector256<float> value) 645Vector256<uint> bitValue = value.AsUInt32(); 648Vector256<uint> sign = Vector256.ShiftRightLogical(bitValue & Vector256.Create(SingleSignMask), 16); 651Vector256<uint> realMask = Vector256.Equals(value, value).AsUInt32(); 660Vector256<uint> exponentOffset0 = Vector256.Max(value, Vector256.Create(MinExp).AsSingle()).AsUInt32(); 673Vector256<uint> maskedHalfExponentForNaN = ~realMask & Vector256.Create(ExponentMask); 679Vector256<uint> newExponent = Vector256.ShiftRightLogical(bitValue, 13); 691Vector256<uint> signAndMaskedExponent = maskedHalfExponentForNaN | sign;
System\Numerics\Tensors\netcore\TensorPrimitives.ConvertSaturating.cs (2)
39public static Vector256<TTo> Invoke(Vector256<TFrom> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.ConvertToInteger.cs (6)
57public static Vector256<TTo> Invoke(Vector256<TFrom> x) 61return Vector256.IsNegative(Vector256<TTo>.AllBitsSet) != Vector256<TTo>.Zero ? 68return Vector256.IsNegative(Vector256<TTo>.AllBitsSet) != Vector256<TTo>.Zero ?
System\Numerics\Tensors\netcore\TensorPrimitives.ConvertToIntegerNative.cs (6)
56public static Vector256<TTo> Invoke(Vector256<TFrom> x) 60return Vector256.IsNegative(Vector256<TTo>.AllBitsSet) != Vector256<TTo>.Zero ? 67return Vector256.IsNegative(Vector256<TTo>.AllBitsSet) != Vector256<TTo>.Zero ?
System\Numerics\Tensors\netcore\TensorPrimitives.ConvertTruncating.cs (28)
111public static Vector256<int> Invoke(Vector256<float> x) => Vector256.ConvertToInt32(x); 123public static Vector256<uint> Invoke(Vector256<float> x) => Vector256.ConvertToUInt32(x); 135public static Vector256<ulong> Invoke(Vector256<double> x) => Vector256.ConvertToUInt64(x); 147public static Vector256<long> Invoke(Vector256<double> x) => Vector256.ConvertToInt64(x); 158public static Vector256<byte> Invoke(Vector256<ushort> lower, Vector256<ushort> upper) => Vector256.Narrow(lower, upper); 169public static Vector256<sbyte> Invoke(Vector256<short> lower, Vector256<short> upper) => Vector256.Narrow(lower, upper); 180public static Vector256<ushort> Invoke(Vector256<uint> lower, Vector256<uint> upper) => Vector256.Narrow(lower, upper); 191public static Vector256<short> Invoke(Vector256<int> lower, Vector256<int> upper) => Vector256.Narrow(lower, upper); 202public static Vector256<uint> Invoke(Vector256<ulong> lower, Vector256<ulong> upper) => Vector256.Narrow(lower, upper); 213public static Vector256<int> Invoke(Vector256<long> lower, Vector256<long> upper) => Vector256.Narrow(lower, upper); 224public static Vector256<TTo> Invoke(Vector256<TFrom> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.CopySign.cs (3)
67public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
System\Numerics\Tensors\netcore\TensorPrimitives.Cos.cs (2)
88public static Vector256<T> Invoke(Vector256<T> x)
System\Numerics\Tensors\netcore\TensorPrimitives.Cosh.cs (8)
101public static Vector256<T> Invoke(Vector256<T> t) 105Vector256<float> x = t.AsSingle(); 107Vector256<float> y = Vector256.Abs(x); 108Vector256<float> z = ExpOperator<float>.Invoke(y - Vector256.Create((float)Single_LOGV)); 114Vector256<double> x = t.AsDouble(); 116Vector256<double> y = Vector256.Abs(x); 117Vector256<double> z = ExpOperator<double>.Invoke(y - Vector256.Create(Double_LOGV));
System\Numerics\Tensors\netcore\TensorPrimitives.CosineSimilarity.cs (41)
98if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 103Vector256<T> dotProductVector = Vector256<T>.Zero; 104Vector256<T> xSumOfSquaresVector = Vector256<T>.Zero; 105Vector256<T> ySumOfSquaresVector = Vector256<T>.Zero; 108int oneVectorFromEnd = x.Length - Vector256<T>.Count; 117i += Vector256<T>.Count; 124Vector256<T> remainderMask = CreateRemainderMaskVector256<T>(x.Length - i); 127Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count)) & remainderMask, 128Vector256.LoadUnsafe(ref yRef, (uint)(x.Length - Vector256<T>.Count)) & remainderMask, 243if (Vector256.IsHardwareAccelerated && x.Length >= Vector256<short>.Count) 249Vector256<float> dotProductVector = Vector256<float>.Zero; 250Vector256<float> xSumOfSquaresVector = Vector256<float>.Zero; 251Vector256<float> ySumOfSquaresVector = Vector256<float>.Zero; 254int oneVectorFromEnd = x.Length - Vector256<short>.Count; 258(Vector256<float> xVecLower, Vector256<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(Vector256.LoadUnsafe(ref xRef, (uint)i)); 259(Vector256<float> yVecLower, Vector256<float> yVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(Vector256.LoadUnsafe(ref yRef, (uint)i)); 264i += Vector256<short>.Count; 271Vector256<short> remainderMask = CreateRemainderMaskVector256<short>(x.Length - i); 273(Vector256<float> xVecLower, Vector256<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke( 274Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<short>.Count)) & remainderMask); 275(Vector256<float> yVecLower, Vector256<float> yVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke( 276Vector256.LoadUnsafe(ref yRef, (uint)(x.Length - Vector256<short>.Count)) & remainderMask); 355private static void Update<T>(Vector256<T> xVec, Vector256<T> yVec, ref Vector256<T> dotProductVector, ref Vector256<T> xSumOfSquaresVector, ref Vector256<T> ySumOfSquaresVector) where T : INumberBase<T> 379private static T Finalize<T>(Vector256<T> dotProductVector, Vector256<T> xSumOfSquaresVector, Vector256<T> ySumOfSquaresVector) where T : IRootFunctions<T> =>
System\Numerics\Tensors\netcore\TensorPrimitives.CosPi.cs (3)
71public static Vector256<T> Invoke(Vector256<T> x) 73Vector256<T> xpi = x * Vector256.Create(T.Pi);
System\Numerics\Tensors\netcore\TensorPrimitives.Decrement.cs (3)
38public static Vector256<T> Invoke(Vector256<T> x) => x - Vector256<T>.One;
System\Numerics\Tensors\netcore\TensorPrimitives.DegreesToRadians.cs (2)
52public static Vector256<T> Invoke(Vector256<T> x)
System\Numerics\Tensors\netcore\TensorPrimitives.Distance.cs (4)
62public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) 64Vector256<T> tmp = x - y;
System\Numerics\Tensors\netcore\TensorPrimitives.Divide.cs (3)
97public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x / y;
System\Numerics\Tensors\netcore\TensorPrimitives.DivRem.cs (5)
90public static (Vector256<T>, Vector256<T>) Invoke(Vector256<T> x, Vector256<T> y) 92Vector256<T> quotient = x / y;
System\Numerics\Tensors\netcore\TensorPrimitives.Exp.cs (2)
62public static Vector256<T> Invoke(Vector256<T> x)
System\Numerics\Tensors\netcore\TensorPrimitives.Exp10.cs (2)
45public static Vector256<T> Invoke(Vector256<T> x) => ExpOperator<T>.Invoke(x * Vector256.Create(T.CreateTruncating(NaturalLog10)));
System\Numerics\Tensors\netcore\TensorPrimitives.Exp10M1.cs (3)
43public static Vector256<T> Invoke(Vector256<T> x) => Exp10Operator<T>.Invoke(x) - Vector256<T>.One;
System\Numerics\Tensors\netcore\TensorPrimitives.Exp2.cs (2)
45public static Vector256<T> Invoke(Vector256<T> x) => ExpOperator<T>.Invoke(x * Vector256.Create(T.CreateTruncating(NaturalLog2)));
System\Numerics\Tensors\netcore\TensorPrimitives.Exp2M1.cs (3)
43public static Vector256<T> Invoke(Vector256<T> x) => Exp2Operator<T>.Invoke(x) - Vector256<T>.One;
System\Numerics\Tensors\netcore\TensorPrimitives.ExpM1.cs (3)
43public static Vector256<T> Invoke(Vector256<T> x) => ExpOperator<T>.Invoke(x) - Vector256<T>.One;
System\Numerics\Tensors\netcore\TensorPrimitives.FloatHelpers.cs (18)
13private static Vector256<float> ApplyScalar<TOperator>(Vector256<float> floats) where TOperator : IUnaryOperator<float, float> => 22private static Vector256<double> ApplyScalar<TOperator>(Vector256<double> doubles) where TOperator : IUnaryOperator<double, double> => 42private static (Vector256<float> First, Vector256<float> Second) Apply2xScalar<TOperator>(Vector256<float> floats) 57(Vector256<float> firstLower, Vector256<float> secondLower) = Apply2xScalar<TOperator>(floats.GetLower()); 58(Vector256<float> firstUpper, Vector256<float> secondUpper) = Apply2xScalar<TOperator>(floats.GetUpper()); 78private static (Vector256<double> First, Vector256<double> Second) Apply2xScalar<TOperator>(Vector256<double> doubles) 93(Vector256<double> firstLower, Vector256<double> secondLower) = Apply2xScalar<TOperator>(doubles.GetLower()); 94(Vector256<double> firstUpper, Vector256<double> secondUpper) = Apply2xScalar<TOperator>(doubles.GetUpper());
System\Numerics\Tensors\netcore\TensorPrimitives.Floor.cs (2)
51public static Vector256<T> Invoke(Vector256<T> x)
System\Numerics\Tensors\netcore\TensorPrimitives.FusedMultiplyAdd.cs (4)
137public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> z)
System\Numerics\Tensors\netcore\TensorPrimitives.Half.cs (31)
327public static Vector256<short> Invoke(Vector256<short> x) 329(Vector256<float> xVecLower, Vector256<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(x); 364public static Vector256<short> Invoke(Vector256<short> x, Vector256<short> y) 366(Vector256<float> xVecLower, Vector256<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(x); 367(Vector256<float> yVecLower, Vector256<float> yVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(y); 403public static Vector256<short> Invoke(Vector256<short> x, Vector256<short> y) 405(Vector256<float> xVecLower, Vector256<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(x); 406(Vector256<float> yVecLower, Vector256<float> yVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(y); 429public static short Invoke(Vector256<short> x) 431(Vector256<float> xVecLower, Vector256<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(x); 470public static Vector256<short> Invoke(Vector256<short> x, Vector256<short> y, Vector256<short> z) 472(Vector256<float> xVecLower, Vector256<float> xVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(x); 473(Vector256<float> yVecLower, Vector256<float> yVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(y); 474(Vector256<float> zVecLower, Vector256<float> zVecUpper) = WidenHalfAsInt16ToSingleOperator.Invoke(z);
System\Numerics\Tensors\netcore\TensorPrimitives.HammingDistance.cs (11)
77if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 116int oneVectorFromEnd = x.Length - Vector256<T>.Count; 120Vector256<T> xVec = Vector256.LoadUnsafe(ref xRef, (uint)i); 121Vector256<T> yVec = Vector256.LoadUnsafe(ref yRef, (uint)i); 125i += Vector256<T>.Count; 132Vector256<T> xVec = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count)); 133Vector256<T> yVec = Vector256.LoadUnsafe(ref yRef, (uint)(x.Length - Vector256<T>.Count)); 135Vector256<T> remainderMask = CreateRemainderMaskVector256<T>(x.Length - i);
System\Numerics\Tensors\netcore\TensorPrimitives.Hypot.cs (3)
56public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
System\Numerics\Tensors\netcore\TensorPrimitives.Ieee754Remainder.cs (3)
64public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.ILogB.cs (5)
41public static Vector256<int> Invoke(Vector256<T> x) => throw new NotSupportedException(); 52public static Vector256<int> Invoke(Vector256<double> lower, Vector256<double> upper) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.Increment.cs (3)
38public static Vector256<T> Invoke(Vector256<T> x) => x + Vector256<T>.One;
System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMax.cs (10)
33public static T Aggregate(Vector256<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x); 64public static Vector256<T> Compare(Vector256<T> x, Vector256<T> y) 68Vector256<T> equalResult = Vector256.IsPositive(x) & Vector256.IsNegative(y); 95private static int IndexOfFirstMatch<T>(Vector256<T> mask) => 119private static unsafe Vector256<T> ElementWiseSelect<T>(Vector256<T> mask, Vector256<T> left, Vector256<T> right)
System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMaxMagnitude.cs (8)
32public static T Aggregate(Vector256<T> x) => HorizontalAggregate<T, MaxMagnitudeOperator<T>>(x); 86public static Vector256<T> Compare(Vector256<T> x, Vector256<T> y) 88Vector256<T> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y); 91Vector256<T> equalResult = Vector256.IsPositive(x) & Vector256.IsNegative(y); 101Vector256<T> equalResult = Vector256.IsPositive(x) & Vector256.IsNegative(y); 102Vector256<T> nonOverflowResult = Vector256.GreaterThan(xMag, yMag) | (Vector256.Equals(xMag, yMag) & equalResult);
System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMin.cs (5)
32public static T Aggregate(Vector256<T> x) => HorizontalAggregate<T, MinOperator<T>>(x); 63public static Vector256<T> Compare(Vector256<T> x, Vector256<T> y) 67Vector256<T> equalResult = Vector256.IsNegative(x) & Vector256.IsPositive(y);
System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMinMagnitude.cs (8)
32public static T Aggregate(Vector256<T> x) => HorizontalAggregate<T, MinMagnitudeOperator<T>>(x); 86public static Vector256<T> Compare(Vector256<T> x, Vector256<T> y) 88Vector256<T> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y); 91Vector256<T> equalResult = Vector256.IsNegative(x) & Vector256.IsPositive(y); 101Vector256<T> equalResult = Vector256.IsNegative(x) & Vector256.IsPositive(y); 102Vector256<T> nonOverflowResult = Vector256.LessThan(xMag, yMag) | (Vector256.Equals(xMag, yMag) & equalResult);
System\Numerics\Tensors\netcore\TensorPrimitives.IsCanonical.cs (3)
69public static Vector256<T> Invoke(Vector256<T> x) => Vector256<T>.AllBitsSet;
System\Numerics\Tensors\netcore\TensorPrimitives.IsComplexNumber.cs (2)
70public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.IsEvenInteger.cs (2)
52public static Vector256<T> Invoke(Vector256<T> x) => Vector256.IsEvenInteger(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsFinite.cs (2)
71public static Vector256<T> Invoke(Vector256<T> x) => Vector256.IsFinite(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsImaginaryNumber.cs (2)
70public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.IsInfinity.cs (2)
58public static Vector256<T> Invoke(Vector256<T> x) => Vector256.IsInfinity(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsInteger.cs (2)
69public static Vector256<T> Invoke(Vector256<T> x) => Vector256.IsInteger(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsNaN.cs (2)
69public static Vector256<T> Invoke(Vector256<T> x) => Vector256.IsNaN<T>(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsNegative.cs (2)
73public static Vector256<T> Invoke(Vector256<T> x) => Vector256.IsNegative<T>(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsNegativeInfinity.cs (2)
58public static Vector256<T> Invoke(Vector256<T> x) => Vector256.IsNegativeInfinity(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsNormal.cs (2)
54public static Vector256<T> Invoke(Vector256<T> x) => Vector256.IsNormal(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsOddInteger.cs (2)
52public static Vector256<T> Invoke(Vector256<T> x) => Vector256.IsOddInteger(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsPositive.cs (2)
51public static Vector256<T> Invoke(Vector256<T> x) => Vector256.IsPositive<T>(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsPositiveInfinity.cs (2)
58public static Vector256<T> Invoke(Vector256<T> x) => Vector256.IsPositiveInfinity(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsPow2.cs (5)
58public static Vector256<T> Invoke(Vector256<T> x) => 59Vector256.Equals(x & (x - Vector256<T>.One), Vector256<T>.Zero) & 60Vector256.GreaterThan(x, Vector256<T>.Zero);
System\Numerics\Tensors\netcore\TensorPrimitives.IsRealNumber.cs (2)
69public static Vector256<T> Invoke(Vector256<T> x) => ~Vector256.IsNaN(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsSubnormal.cs (2)
58public static Vector256<T> Invoke(Vector256<T> x) => Vector256.IsSubnormal(x);
System\Numerics\Tensors\netcore\TensorPrimitives.IsZero.cs (3)
51public static Vector256<T> Invoke(Vector256<T> x) => Vector256.Equals(x, Vector256<T>.Zero);
System\Numerics\Tensors\netcore\TensorPrimitives.LeadingZeroCount.cs (15)
117public static Vector256<T> Invoke(Vector256<T> x) 121Vector256<byte> lookupVector = 124Vector256<byte> nibbleMask = Vector256.Create<byte>(0xF); 125Vector256<byte> lowNibble = x.AsByte() & nibbleMask; 126Vector256<byte> highNibble = (x.AsInt32() >>> 4).AsByte() & nibbleMask; 127Vector256<byte> nibbleSelectMask = Avx2.CompareEqual(highNibble, Vector256<byte>.Zero); 128Vector256<byte> indexVector = Avx2.BlendVariable(highNibble, lowNibble, nibbleSelectMask) + 137Vector256<uint> lowHalf = Vector256.Create((uint)0x0000FFFF); 138Vector256<uint> x_bot16 = (x.AsUInt32() << 16) | lowHalf; 139Vector256<uint> x_top16 = x.AsUInt32() | lowHalf; 140Vector256<uint> lz_bot16 = Avx512CD.VL.LeadingZeroCount(x_bot16); 141Vector256<uint> lz_top16 = Avx512CD.VL.LeadingZeroCount(x_top16); 142Vector256<uint> lz_top16_shift = lz_top16 << 16;
System\Numerics\Tensors\netcore\TensorPrimitives.Lerp.cs (4)
116public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> amount)
System\Numerics\Tensors\netcore\TensorPrimitives.Log.cs (5)
118public static Vector256<T> Invoke(Vector256<T> x) 152public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => LogOperator<T>.Invoke(x) / LogOperator<T>.Invoke(y);
System\Numerics\Tensors\netcore\TensorPrimitives.Log10.cs (2)
49public static Vector256<T> Invoke(Vector256<T> x) => LogOperator<T>.Invoke(x) / Vector256.Create(T.CreateTruncating(NaturalLog10));
System\Numerics\Tensors\netcore\TensorPrimitives.Log10P1.cs (3)
48public static Vector256<T> Invoke(Vector256<T> x) => Log10Operator<T>.Invoke(x + Vector256<T>.One);
System\Numerics\Tensors\netcore\TensorPrimitives.Log2.cs (2)
64public static Vector256<T> Invoke(Vector256<T> x)
System\Numerics\Tensors\netcore\TensorPrimitives.Log2P1.cs (3)
48public static Vector256<T> Invoke(Vector256<T> x) => Log2Operator<T>.Invoke(x + Vector256<T>.One);
System\Numerics\Tensors\netcore\TensorPrimitives.LogP1.cs (3)
48public static Vector256<T> Invoke(Vector256<T> x) => LogOperator<T>.Invoke(x + Vector256<T>.One);
System\Numerics\Tensors\netcore\TensorPrimitives.Max.cs (16)
112public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => Vector256.Max(x, y); 118public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x); 205if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count) 211Vector256<T> result = Vector256.LoadUnsafe(ref xRef, 0); 212Vector256<T> current; 214Vector256<T> nanMask; 219if (nanMask != Vector256<T>.Zero) 225int oneVectorFromEnd = x.Length - Vector256<T>.Count; 226int i = Vector256<T>.Count; 238if (nanMask != Vector256<T>.Zero) 245i += Vector256<T>.Count; 251current = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count)); 258if (nanMask != Vector256<T>.Zero)
System\Numerics\Tensors\netcore\TensorPrimitives.MaxMagnitude.cs (4)
103public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) 115public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MaxMagnitudeOperator<T>>(x);
System\Numerics\Tensors\netcore\TensorPrimitives.MaxMagnitudeNumber.cs (4)
118public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) 130public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MaxMagnitudeNumberOperator<T>>(x);
System\Numerics\Tensors\netcore\TensorPrimitives.MaxNumber.cs (4)
111public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) 123public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MaxNumberOperator<T>>(x);
System\Numerics\Tensors\netcore\TensorPrimitives.Min.cs (4)
111public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => Vector256.Min(x, y); 117public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MinOperator<T>>(x);
System\Numerics\Tensors\netcore\TensorPrimitives.MinMagnitude.cs (4)
113public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) 125public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MinMagnitudeOperator<T>>(x);
System\Numerics\Tensors\netcore\TensorPrimitives.MinMagnitudeNumber.cs (4)
118public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) 130public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MinMagnitudeNumberOperator<T>>(x);
System\Numerics\Tensors\netcore\TensorPrimitives.MinNumber.cs (4)
111public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) 123public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MinNumberOperator<T>>(x);
System\Numerics\Tensors\netcore\TensorPrimitives.Multiply.cs (4)
70public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x * y; 74public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MultiplyOperator<T>>(x);
System\Numerics\Tensors\netcore\TensorPrimitives.MultiplyAdd.cs (4)
102public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> z) => (x * y) + z;
System\Numerics\Tensors\netcore\TensorPrimitives.MultiplyAddEstimate.cs (4)
139public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> z)
System\Numerics\Tensors\netcore\TensorPrimitives.Negate.cs (2)
40public static Vector256<T> Invoke(Vector256<T> x) => -x;
System\Numerics\Tensors\netcore\TensorPrimitives.OnesComplement.cs (2)
37public static Vector256<T> Invoke(Vector256<T> x) => ~x;
System\Numerics\Tensors\netcore\TensorPrimitives.PopCount.cs (16)
136public static Vector256<T> Invoke(Vector256<T> x) 140Vector256<byte> c1 = Vector256.Create((byte)0x55); 141Vector256<byte> c2 = Vector256.Create((byte)0x33); 142Vector256<byte> c3 = Vector256.Create((byte)0x0F); 148Vector256<byte> tmp = x.AsByte(); 156Vector256<ushort> c1 = Vector256.Create((ushort)0x5555); 157Vector256<ushort> c2 = Vector256.Create((ushort)0x3333); 158Vector256<ushort> c3 = Vector256.Create((ushort)0x0F0F); 159Vector256<ushort> c4 = Vector256.Create((ushort)0x0101); 161Vector256<ushort> tmp = x.AsUInt16(); 170Vector256<uint> c1 = Vector256.Create(0x55555555u); 171Vector256<uint> c2 = Vector256.Create(0x33333333u); 172Vector256<uint> c3 = Vector256.Create(0x0F0F0F0Fu); 173Vector256<uint> c4 = Vector256.Create(0x01010101u); 175Vector256<uint> tmp = x.AsUInt32();
System\Numerics\Tensors\netcore\TensorPrimitives.Pow.cs (3)
79public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
System\Numerics\Tensors\netcore\TensorPrimitives.RadiansToDegrees.cs (2)
45public static Vector256<T> Invoke(Vector256<T> x)
System\Numerics\Tensors\netcore\TensorPrimitives.Reciprocal.cs (12)
105public static Vector256<T> Invoke(Vector256<T> x) => Vector256<T>.One / x; 114public static Vector256<T> Invoke(Vector256<T> x) => Vector256<T>.One / Vector256.Sqrt(x); 150public static Vector256<T> Invoke(Vector256<T> x) 163return Vector256<T>.One / x; 210public static Vector256<T> Invoke(Vector256<T> x) 223return Vector256<T>.One / Vector256.Sqrt(x);
System\Numerics\Tensors\netcore\TensorPrimitives.Remainder.cs (3)
102public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) =>
System\Numerics\Tensors\netcore\TensorPrimitives.RootN.cs (2)
48public Vector256<T> Invoke(Vector256<T> x)
System\Numerics\Tensors\netcore\TensorPrimitives.Rotate.cs (4)
49public Vector256<T> Invoke(Vector256<T> x) => (x << _amount) | (x >>> ((sizeof(T) * 8) - _amount)); 62public Vector256<T> Invoke(Vector256<T> x) => (x >>> _amount) | (x << ((sizeof(T) * 8) - _amount));
System\Numerics\Tensors\netcore\TensorPrimitives.Round.cs (6)
159public static Vector256<T> Invoke(Vector256<T> x) 216public static Vector256<T> Invoke(Vector256<T> x) 255public Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.ScaleB.cs (2)
35public Vector256<T> Invoke(Vector256<T> x) => x * Vector256.Create(_pow2n);
System\Numerics\Tensors\netcore\TensorPrimitives.ShiftLeft.cs (2)
34public Vector256<T> Invoke(Vector256<T> x) => x << _amount;
System\Numerics\Tensors\netcore\TensorPrimitives.ShiftRightArithmetic.cs (2)
34public Vector256<T> Invoke(Vector256<T> x) => x >> _amount;
System\Numerics\Tensors\netcore\TensorPrimitives.ShiftRightLogical.cs (2)
34public Vector256<T> Invoke(Vector256<T> x) => x >>> _amount;
System\Numerics\Tensors\netcore\TensorPrimitives.Sigmoid.cs (2)
47public static Vector256<T> Invoke(Vector256<T> x) => Vector256.Create(T.One) / (Vector256.Create(T.One) + ExpOperator<T>.Invoke(-x));
System\Numerics\Tensors\netcore\TensorPrimitives.Sign.cs (11)
63public static Vector256<int> Invoke(Vector256<T> x) 67return Vector256.ConditionalSelect(Vector256.Equals(x, Vector256<T>.Zero).AsInt32(), 68Vector256<int>.Zero, 69Vector256<int>.One); 74Vector256<int> value = x.AsInt32(); 78if (Vector256.EqualsAny(Vector256.IsNaN(x).AsInt32(), Vector256<int>.AllBitsSet)) 83return Vector256.ConditionalSelect(Vector256.LessThan(x, Vector256<T>.Zero).AsInt32(), 85Vector256.ConditionalSelect(Vector256.GreaterThan(x, Vector256<T>.Zero).AsInt32(), 86Vector256<int>.One, 87Vector256<int>.Zero));
System\Numerics\Tensors\netcore\TensorPrimitives.Sin.cs (2)
78public static Vector256<T> Invoke(Vector256<T> x)
System\Numerics\Tensors\netcore\TensorPrimitives.SinCos.cs (3)
36public static (Vector256<T> First, Vector256<T> Second) Invoke(Vector256<T> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.SinCosPi.cs (3)
36public static (Vector256<T> First, Vector256<T> Second) Invoke(Vector256<T> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.Sinh.cs (12)
87public static Vector256<T> Invoke(Vector256<T> t) 91Vector256<float> x = t.AsSingle(); 93Vector256<float> y = Vector256.Abs(x); 94Vector256<float> z = ExpOperator<float>.Invoke(y - Vector256.Create((float)Single_LOGV)); 95Vector256<float> result = Vector256.Create((float)Single_HALFV) * (z - (Vector256.Create((float)Single_INVV2) / z)); 96Vector256<uint> sign = x.AsUInt32() & Vector256.Create(~(uint)int.MaxValue); 102Vector256<double> x = t.AsDouble(); 104Vector256<double> y = Vector256.Abs(x); 105Vector256<double> z = ExpOperator<double>.Invoke(y - Vector256.Create(Double_LOGV)); 106Vector256<double> result = Vector256.Create(Double_HALFV) * (z - (Vector256.Create(Double_INVV2) / z)); 107Vector256<ulong> sign = x.AsUInt64() & Vector256.Create(~(ulong)long.MaxValue);
System\Numerics\Tensors\netcore\TensorPrimitives.SinPi.cs (3)
71public static Vector256<T> Invoke(Vector256<T> x) 73Vector256<T> xpi = x * Vector256.Create(T.Pi);
System\Numerics\Tensors\netcore\TensorPrimitives.Sqrt.cs (2)
38public static Vector256<T> Invoke(Vector256<T> x) => Vector256.Sqrt(x);
System\Numerics\Tensors\netcore\TensorPrimitives.StdDev.cs (3)
54public Vector256<T> Invoke(Vector256<T> x) 56Vector256<T> diff = x - Vector256.Create(_subtrahend);
System\Numerics\Tensors\netcore\TensorPrimitives.Subtract.cs (3)
93public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x - y;
System\Numerics\Tensors\netcore\TensorPrimitives.Sum.cs (2)
77public static Vector256<T> Invoke(Vector256<T> x) => x * x;
System\Numerics\Tensors\netcore\TensorPrimitives.Tan.cs (48)
81public static Vector256<T> Invoke(Vector256<T> x) 163public static Vector256<float> Invoke(Vector256<float> x) 165Vector256<float> uxMasked = Vector256.Abs(x); 171Vector256<float> dn = MultiplyAddEstimateOperator<float>.Invoke(uxMasked, Vector256.Create(2 / float.Pi), Vector256.Create(AlmHuge)); 172Vector256<uint> odd = dn.AsUInt32() << 31; 175Vector256<float> f = uxMasked; 181Vector256<float> f2 = f * f; 182Vector256<float> f4 = f2 * f2; 183Vector256<float> f8 = f4 * f4; 184Vector256<float> f12 = f8 * f4; 185Vector256<float> a1 = MultiplyAddEstimateOperator<float>.Invoke(Vector256.Create(C2), f2, Vector256.Create(C1)); 186Vector256<float> a2 = MultiplyAddEstimateOperator<float>.Invoke(Vector256.Create(C4), f2, Vector256.Create(C3)); 187Vector256<float> a3 = MultiplyAddEstimateOperator<float>.Invoke(Vector256.Create(C6), f2, Vector256.Create(C5)); 188Vector256<float> b1 = MultiplyAddEstimateOperator<float>.Invoke(a2, f4, a1); 189Vector256<float> b2 = MultiplyAddEstimateOperator<float>.Invoke(f8, a3, f12 * Vector256.Create(C7)); 190Vector256<float> poly = MultiplyAddEstimateOperator<float>.Invoke(f * f2, b1 + b2, f); 192Vector256<float> result = (poly.AsUInt32() ^ (x.AsUInt32() & Vector256.Create(~SignMask))).AsSingle(); 193return Vector256.ConditionalSelect(Vector256.Equals(odd, Vector256<uint>.Zero).AsSingle(), 308public static Vector256<double> Invoke(Vector256<double> x) 310Vector256<double> uxMasked = Vector256.Abs(x); 317Vector256<double> dn = MultiplyAddEstimateOperator<double>.Invoke(uxMasked, Vector256.Create(2 / double.Pi), Vector256.Create(AlmHuge)); 318Vector256<ulong> odd = dn.AsUInt64() << 63; 322Vector256<double> f = uxMasked; 328Vector256<double> g = f * f; 329Vector256<double> g2 = g * g; 330Vector256<double> g3 = g * g2; 331Vector256<double> g5 = g3 * g2; 332Vector256<double> g7 = g5 * g2; 333Vector256<double> g9 = g7 * g2; 334Vector256<double> g11 = g9 * g2; 335Vector256<double> g13 = g11 * g2; 336Vector256<double> a1 = MultiplyAddEstimateOperator<double>.Invoke(Vector256.Create(C3), g, Vector256.Create(C1)); 337Vector256<double> a2 = MultiplyAddEstimateOperator<double>.Invoke(Vector256.Create(C7), g, Vector256.Create(C5)); 338Vector256<double> a3 = MultiplyAddEstimateOperator<double>.Invoke(Vector256.Create(C11), g, Vector256.Create(C9)); 339Vector256<double> a4 = MultiplyAddEstimateOperator<double>.Invoke(Vector256.Create(C15), g, Vector256.Create(C13)); 340Vector256<double> a5 = MultiplyAddEstimateOperator<double>.Invoke(Vector256.Create(C19), g, Vector256.Create(C17)); 341Vector256<double> a6 = MultiplyAddEstimateOperator<double>.Invoke(Vector256.Create(C23), g, Vector256.Create(C21)); 342Vector256<double> a7 = MultiplyAddEstimateOperator<double>.Invoke(Vector256.Create(C27), g, Vector256.Create(C25)); 343Vector256<double> b1 = MultiplyAddEstimateOperator<double>.Invoke(g, a1, g3 * a2); 344Vector256<double> b2 = MultiplyAddEstimateOperator<double>.Invoke(g5, a3, g7 * a4); 345Vector256<double> b3 = MultiplyAddEstimateOperator<double>.Invoke(g9, a5, g11 * a6); 346Vector256<double> q = MultiplyAddEstimateOperator<double>.Invoke(g13, a7, b1 + b2 + b3); 347Vector256<double> poly = MultiplyAddEstimateOperator<double>.Invoke(f, q, f); 349Vector256<double> result = (poly.AsUInt64() ^ (x.AsUInt64() & Vector256.Create(~SignMask))).AsDouble(); 350return Vector256.ConditionalSelect(Vector256.Equals(odd, Vector256<ulong>.Zero).AsDouble(),
System\Numerics\Tensors\netcore\TensorPrimitives.Tanh.cs (10)
92public static Vector256<T> Invoke(Vector256<T> t) 96Vector256<float> x = t.AsSingle(); 98Vector256<float> y = Vector256.Abs(x); 99Vector256<float> z = ExpM1Operator<float>.Invoke(Vector256.Create(-2f) * y); 100Vector256<uint> sign = x.AsUInt32() & Vector256.Create(~(uint)int.MaxValue); 105Vector256<double> x = t.AsDouble(); 107Vector256<double> y = Vector256.Abs(x); 108Vector256<double> z = ExpM1Operator<double>.Invoke(Vector256.Create(-2d) * y); 109Vector256<ulong> sign = x.AsUInt64() & Vector256.Create(~(ulong)long.MaxValue);
System\Numerics\Tensors\netcore\TensorPrimitives.TanPi.cs (2)
45public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
System\Numerics\Tensors\netcore\TensorPrimitives.TrailingZeroCount.cs (3)
49public static Vector256<T> Invoke(Vector256<T> x) 52return PopCountOperator<T>.Invoke(~x & (x - Vector256<T>.One));
System\Numerics\Tensors\netcore\TensorPrimitives.Truncate.cs (2)
53public static Vector256<T> Invoke(Vector256<T> x)
System\Numerics\Tensors\netcore\TensorPrimitives.Xor.cs (3)
62public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x ^ y;
System.Private.CoreLib (5719)
src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.ReverseEndianness.cs (12)
253public static Vector256<short> Reverse(Vector256<short> vector) => 267public static Vector256<int> Reverse(Vector256<int> vector) => 281public static Vector256<long> Reverse(Vector256<long> vector) => 310while (i <= source.Length - Vector256<T>.Count) 313i += Vector256<T>.Count; 342while (i >= Vector256<T>.Count) 344i -= Vector256<T>.Count; 370static abstract Vector256<T> Reverse(Vector256<T> vector);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64DecoderHelper.cs (42)
919Vector256<sbyte> lutHi = Vector256.Create(decoder.Avx2LutHigh); 921Vector256<sbyte> lutLo = Vector256.Create(decoder.Avx2LutLow); 923Vector256<sbyte> lutShift = Vector256.Create(decoder.Avx2LutShift); 925Vector256<sbyte> packBytesInLaneMask = Vector256.Create( 935Vector256<int> packLanesControl = Vector256.Create( 945Vector256<sbyte> maskSlashOrUnderscore = Vector256.Create((sbyte)decoder.MaskSlashOrUnderscore); 946Vector256<sbyte> shiftForUnderscore = Vector256.Create((sbyte)33); 947Vector256<sbyte> mergeConstant0 = Vector256.Create(0x01400140).AsSByte(); 948Vector256<short> mergeConstant1 = Vector256.Create(0x00011000).AsInt16(); 956if (!decoder.TryLoadAvxVector256(src, srcStart, sourceLength, out Vector256<sbyte> str)) 961Vector256<sbyte> hiNibbles = ((str.AsInt32()) >>> 4).AsSByte() & maskSlashOrUnderscore; 974Vector256<short> merge_ab_and_bc = Avx2.MultiplyAddAdjacent(str.AsByte(), mergeConstant0); 980Vector256<int> output = Avx2.MultiplyAddAdjacent(merge_ab_and_bc, mergeConstant1); 996AssertWrite<Vector256<sbyte>>(dest, destStart, destLength); 1519Vector256<sbyte> str, 1520Vector256<sbyte> hiNibbles, 1521Vector256<sbyte> maskSlashOrUnderscore, 1522Vector256<sbyte> lutLow, 1523Vector256<sbyte> lutHigh, 1524Vector256<sbyte> lutShift, 1525Vector256<sbyte> _, 1526out Vector256<sbyte> result) 1528Vector256<sbyte> loNibbles = str & maskSlashOrUnderscore; 1529Vector256<sbyte> hi = Avx2.Shuffle(lutHigh, hiNibbles); 1530Vector256<sbyte> lo = Avx2.Shuffle(lutLow, loNibbles); 1532if ((lo & hi) != Vector256<sbyte>.Zero) 1538Vector256<sbyte> eq2F = Avx2.CompareEqual(str, maskSlashOrUnderscore); 1539Vector256<sbyte> shift = Avx2.Shuffle(lutShift, eq2F + hiNibbles); 1556public unsafe bool TryLoadAvxVector256(byte* src, byte* srcStart, int sourceLength, out Vector256<sbyte> str) 1558AssertRead<Vector256<sbyte>>(src, srcStart, sourceLength); 1712public bool TryDecode256Core(Vector256<sbyte> str, Vector256<sbyte> hiNibbles, Vector256<sbyte> maskSlashOrUnderscore, Vector256<sbyte> lutLow, 1713Vector256<sbyte> lutHigh, Vector256<sbyte> lutShift, Vector256<sbyte> shiftForUnderscore, out Vector256<sbyte> result) => 1734public unsafe bool TryLoadAvxVector256(ushort* src, ushort* srcStart, int sourceLength, out Vector256<sbyte> str) 1736AssertRead<Vector256<sbyte>>(src, srcStart, sourceLength); 1737Vector256<ushort> utf16VectorLower = Avx.LoadVector256(src); 1738Vector256<ushort> utf16VectorUpper = Avx.LoadVector256(src + 16);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64EncoderHelper.cs (25)
164AssertRead<Vector256<sbyte>>(src, srcStart, sourceLength); 230Vector256<sbyte> shuffleVec = Vector256.Create( 240Vector256<sbyte> lut = Vector256.Create( 250Vector256<sbyte> maskAC = Vector256.Create(0x0fc0fc00).AsSByte(); 251Vector256<sbyte> maskBB = Vector256.Create(0x003f03f0).AsSByte(); 252Vector256<ushort> shiftAC = Vector256.Create(0x04000040).AsUInt16(); 253Vector256<short> shiftBB = Vector256.Create(0x01000010).AsInt16(); 254Vector256<byte> const51 = Vector256.Create((byte)51); 255Vector256<sbyte> const25 = Vector256.Create((sbyte)25); 261AssertRead<Vector256<sbyte>>(src, srcStart, sourceLength); 262Vector256<sbyte> str = Avx.LoadVector256(src).AsSByte(); 292Vector256<sbyte> t0 = str & maskAC; 303Vector256<sbyte> t2 = str & maskBB; 313Vector256<ushort> t1 = Avx2.MultiplyHigh(t0.AsUInt16(), shiftAC); 323Vector256<short> t3 = t2.AsInt16() * shiftBB; 355Vector256<byte> indices = Avx2.SubtractSaturate(str.AsByte(), const51); 358Vector256<sbyte> mask = Avx2.CompareGreaterThan(str, const25); 361Vector256<sbyte> tmp = indices.AsSByte() - mask; 375AssertRead<Vector256<sbyte>>(src, srcStart, sourceLength); 785public unsafe void StoreVector256ToDestination(byte* dest, byte* destStart, int destLength, Vector256<byte> str) 787AssertWrite<Vector256<sbyte>>(dest, destStart, destLength); 865public unsafe void StoreVector256ToDestination(ushort* dest, ushort* destStart, int destLength, Vector256<byte> str) 867AssertWrite<Vector256<short>>(dest, destStart, destLength); 868(Vector256<ushort> utf16LowVector, Vector256<ushort> utf16HighVector) = Vector256.Widen(str);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64Helper.cs (10)
98unsafe void StoreVector256ToDestination(T* dest, T* destStart, int destLength, Vector256<byte> str); 135Vector256<sbyte> str, 136Vector256<sbyte> hiNibbles, 137Vector256<sbyte> maskSlashOrUnderscore, 138Vector256<sbyte> lutLow, 139Vector256<sbyte> lutHigh, 140Vector256<sbyte> lutShift, 141Vector256<sbyte> shiftForUnderscore, 142out Vector256<sbyte> result); 144unsafe bool TryLoadAvxVector256(T* src, T* srcStart, int sourceLength, out Vector256<sbyte> str);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlDecoder.cs (26)
415Vector256<sbyte> str, 416Vector256<sbyte> hiNibbles, 417Vector256<sbyte> maskSlashOrUnderscore, 418Vector256<sbyte> lutLow, 419Vector256<sbyte> lutHigh, 420Vector256<sbyte> lutShift, 421Vector256<sbyte> shiftForUnderscore, 422out Vector256<sbyte> result) 424Vector256<sbyte> lowerBound = Avx2.Shuffle(lutLow, hiNibbles); 425Vector256<sbyte> upperBound = Avx2.Shuffle(lutHigh, hiNibbles); 427Vector256<sbyte> below = Vector256.LessThan(str, lowerBound); 428Vector256<sbyte> above = Vector256.GreaterThan(str, upperBound); 429Vector256<sbyte> eq5F = Vector256.Equals(str, maskSlashOrUnderscore); 432Vector256<sbyte> outside = Vector256.AndNot(below | above, eq5F); 434if (outside != Vector256<sbyte>.Zero) 440Vector256<sbyte> shift = Avx2.Shuffle(lutShift, hiNibbles); 453public unsafe bool TryLoadAvxVector256(byte* src, byte* srcStart, int sourceLength, out Vector256<sbyte> str) => 528public bool TryDecode256Core(Vector256<sbyte> str, Vector256<sbyte> hiNibbles, Vector256<sbyte> maskSlashOrUnderscore, Vector256<sbyte> lutLow, 529Vector256<sbyte> lutHigh, Vector256<sbyte> lutShift, Vector256<sbyte> shiftForUnderscore, out Vector256<sbyte> result) => 538public unsafe bool TryLoadAvxVector256(ushort* src, ushort* srcStart, int sourceLength, out Vector256<sbyte> str) =>
src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlEncoder.cs (2)
294public unsafe void StoreVector256ToDestination(byte* dest, byte* destStart, int destLength, Vector256<byte> str) => 350public unsafe void StoreVector256ToDestination(ushort* dest, ushort* destStart, int destLength, Vector256<byte> str) =>
src\runtime\src\libraries\System.Private.CoreLib\src\System\Collections\BitArray.cs (21)
218if (!BitConverter.IsLittleEndian || values.Length < Vector256<byte>.Count) 244while (valuesAsBytes.Length >= Vector256<byte>.Count) 246Vector256<byte> vector = Vector256.Create(valuesAsBytes); 247Vector256<byte> isFalse = Vector256.Equals(vector, Vector256<byte>.Zero); 251i += (uint)Vector256<byte>.Count; 252valuesAsBytes = valuesAsBytes.Slice(Vector256<byte>.Count); 524i = Apply<Vector256<byte>>(count, thisArray, valueArray); 839Vector256<byte> upperShuffleMask_CopyToBoolArray256 = Vector256.Create(0x04040404_04040404, 0x05050505_05050505, 841Vector256<byte> lowerShuffleMask_CopyToBoolArray256 = Vector256.Create(lowerShuffleMask_CopyToBoolArray, upperShuffleMask_CopyToBoolArray); 862else if (Vector256.IsHardwareAccelerated && (uint)_bitLength >= Vector256<byte>.Count) 864Vector256<byte> shuffleMask = Vector256.Create(lowerShuffleMask_CopyToBoolArray, upperShuffleMask_CopyToBoolArray); 865Vector256<byte> bitMask = Vector256.Create(0x80402010_08040201).AsByte(); 866Vector256<byte> ones = Vector256<byte>.One; 870for (; (i + Vector256<byte>.Count) <= (uint)_bitLength; i += (uint)Vector256<byte>.Count) 873Vector256<int> scalar = Vector256.Create(bits); 874Vector256<byte> shuffled = Vector256.Shuffle(scalar.AsByte(), shuffleMask); 875Vector256<byte> extracted = shuffled & bitMask; 879Vector256<byte> normalized = Vector256.Min(extracted, ones);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\Ordinal.cs (12)
171if (Vector256.IsHardwareAccelerated && length >= Vector256<ushort>.Count) 173return EqualsIgnoreCase_Vector<Vector256<ushort>>(ref charA, ref charB, length); 456if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector256<ushort>.Count >= 0) 459Vector256<ushort> ch1 = Vector256.Create((ushort)valueChar); 460Vector256<ushort> ch2 = Vector256.Create((ushort)valueCharU); 462nint searchSpaceMinusValueTailLengthAndVector = searchSpaceMinusValueTailLength - (nint)Vector256<ushort>.Count; 466Debug.Assert(offset + ch1ch2Distance + Vector256<ushort>.Count <= source.Length); 471Vector256<ushort> cmpCh2 = Vector256.Equals(ch2, Vector256.BitwiseOr(Vector256.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance)), Vector256.Create((ushort)0x20))); 472Vector256<ushort> cmpCh1 = Vector256.Equals(ch1, Vector256.BitwiseOr(Vector256.LoadUnsafe(ref searchSpace, (nuint)offset), Vector256.Create((ushort)0x20))); 473Vector256<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte(); 474if (cmpAnd != Vector256<byte>.Zero) 481offset += Vector256<ushort>.Count;
src\runtime\src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.MinMax.cs (16)
204static abstract Vector256<T> Compare(Vector256<T> left, Vector256<T> right); 212public static Vector256<T> Compare(Vector256<T> left, Vector256<T> right) => Vector256.Min(left, right); 220public static Vector256<T> Compare(Vector256<T> left, Vector256<T> right) => Vector256.Max(left, right); 257if (!Vector256.IsHardwareAccelerated || span.Length < Vector256<T>.Count) 273Vector256<T> best = Vector256.Create(data); 274data = data.Slice(Vector256<T>.Count); 276while (data.Length > Vector256<T>.Count) 279data = data.Slice(Vector256<T>.Count); 281best = TMinMax.Compare(best, Vector256.Create(span.Slice(span.Length - Vector256<T>.Count))); 300Vector256<T> best256 = TMinMax.Compare(best.GetLower(), best.GetUpper());
src\runtime\src\libraries\System.Private.CoreLib\src\System\Numerics\Vector.cs (18)
474else if (Vector<double>.Count == Vector256<double>.Count) 497else if (Vector<double>.Count == Vector256<double>.Count) 605else if (Vector<float>.Count == Vector256<float>.Count) 768else if (Vector<T>.Count == Vector256<T>.Count) 887else if (Vector<T>.Count == Vector256<T>.Count) 942else if (Vector<T>.Count == Vector256<T>.Count) 966else if (Vector<T>.Count == Vector256<T>.Count) 990else if (Vector<T>.Count == Vector256<T>.Count) 1014else if (Vector<T>.Count == Vector256<T>.Count) 1038else if (Vector<T>.Count == Vector256<T>.Count) 1062else if (Vector<T>.Count == Vector256<T>.Count) 1095else if (Vector<T>.Count == Vector256<T>.Count) 1119else if (Vector<T>.Count == Vector256<T>.Count) 1151else if (Vector<T>.Count == Vector256<T>.Count) 1705else if (Vector<T>.Count == Vector256<T>.Count) 1943else if (Vector<T>.Count == Vector256<T>.Count) 2985else if (Vector<uint>.Count == Vector256<uint>.Count) 3011else if (Vector<ulong>.Count == Vector256<ulong>.Count)
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128.cs (21)
834return VectorMath.AsinSingle<Vector128<float>, Vector128<int>, Vector256<double>, Vector256<long>>(vector); 875return VectorMath.CosSingle<Vector128<float>, Vector128<int>, Vector256<double>, Vector256<long>>(vector); 1759return VectorMath.DegreesToRadiansSingle<Vector128<float>, Vector256<double>>(degrees); 1866return VectorMath.ExpSingle<Vector128<float>, Vector128<uint>, Vector256<double>, Vector256<ulong>>(vector); 2112return VectorMath.HypotSingle<Vector128<float>, Vector256<double>>(x, y); 3140return VectorMath.RadiansToDegreesSingle<Vector128<float>, Vector256<double>>(radians); 3659return VectorMath.SinSingle<Vector128<float>, Vector128<int>, Vector256<double>, Vector256<long>>(vector); 3703return VectorMath.SinCosSingle<Vector128<float>, Vector128<int>, Vector256<double>, Vector256<long>>(vector); 3884/// <summary>Converts the given vector to a new <see cref="Vector256{T}" /> with the lower 128-bits set to the value of the given vector and the upper 128-bits initialized to zero.</summary> 3887/// <returns>A new <see cref="Vector256{T}" /> with the lower 128-bits set to the value of <paramref name="vector" /> and the upper 128-bits initialized to zero.</returns> 3891public static Vector256<T> ToVector256<T>(this Vector128<T> vector) 3895Vector256<T> result = default; 3900/// <summary>Converts the given vector to a new <see cref="Vector256{T}" /> with the lower 128-bits set to the value of the given vector and the upper 128-bits left uninitialized.</summary> 3903/// <returns>A new <see cref="Vector256{T}" /> with the lower 128-bits set to the value of <paramref name="vector" /> and the upper 128-bits left uninitialized.</returns> 3907public static Vector256<T> ToVector256Unsafe<T>(this Vector128<T> vector) 3914Unsafe.SkipInit(out Vector256<T> result);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256_1.cs (367)
31public readonly unsafe struct Vector256<T> : ISimdVector<Vector256<T>, T> 36/// <summary>Gets a new <see cref="Vector256{T}" /> with all bits set to 1.</summary> 38public static Vector256<T> AllBitsSet 44/// <summary>Gets the number of <typeparamref name="T" /> that are in a <see cref="Vector256{T}" />.</summary> 56/// <summary>Gets a new <see cref="Vector256{T}" /> with the elements set to their index.</summary> 58public static Vector256<T> Indices 65Unsafe.SkipInit(out Vector256<T> result); 99/// <summary>Gets a new <see cref="Vector256{T}" /> with all elements initialized to one.</summary> 101public static Vector256<T> One 107/// <summary>Gets a new <see cref="Vector256{T}" /> with all elements initialized to zero.</summary> 109public static Vector256<T> Zero 135public static Vector256<T> operator +(Vector256<T> left, Vector256<T> right) 150public static Vector256<T> operator &(Vector256<T> left, Vector256<T> right) 165public static Vector256<T> operator |(Vector256<T> left, Vector256<T> right) 180public static Vector256<T> operator /(Vector256<T> left, Vector256<T> right) 194public static Vector256<T> operator /(Vector256<T> left, T right) 209public static bool operator ==(Vector256<T> left, Vector256<T> right) 222public static Vector256<T> operator ^(Vector256<T> left, Vector256<T> right) 236public static bool operator !=(Vector256<T> left, Vector256<T> right) => !(left == right); 244public static Vector256<T> operator <<(Vector256<T> value, int shiftCount) 259public static Vector256<T> operator *(Vector256<T> left, Vector256<T> right) 274public static Vector256<T> operator *(Vector256<T> left, T right) 288public static Vector256<T> operator *(T left, Vector256<T> right) => right * left; 296public static Vector256<T> operator ~(Vector256<T> vector) 310public static Vector256<T> operator >>(Vector256<T> value, int shiftCount) 325public static Vector256<T> operator -(Vector256<T> left, Vector256<T> right) 339public static Vector256<T> operator -(Vector256<T> vector) 343return vector ^ Vector256<float>.NegativeZero.As<float, T>(); 347return vector ^ Vector256<double>.NegativeZero.As<double, T>(); 360public static Vector256<T> operator +(Vector256<T> value) 372public static Vector256<T> operator >>>(Vector256<T> value, int shiftCount) 382/// <returns><c>true</c> if <paramref name="obj" /> is a <see cref="Vector256{T}" /> and is equal to the current instance; otherwise, <c>false</c>.</returns> 383public override bool Equals([NotNullWhen(true)] object? obj) => (obj is Vector256<T> other) && Equals(other); 385/// <summary>Determines whether the specified <see cref="Vector256{T}" /> is equal to the current instance.</summary> 386/// <param name="other">The <see cref="Vector256{T}" /> to compare with the current instance.</param> 390public bool Equals(Vector256<T> other) 399Vector256<T> result = Vector256.Equals(this, other) | ~(Vector256.Equals(this, this) | Vector256.Equals(other, other)); 400return result.AsInt32() == Vector256<int>.AllBitsSet; 461static int ISimdVector<Vector256<T>, T>.Alignment => Vector256.Alignment; 464static int ISimdVector<Vector256<T>, T>.ElementCount => Vector256<T>.Count; 467static bool ISimdVector<Vector256<T>, T>.IsHardwareAccelerated 475static Vector256<T> ISimdVector<Vector256<T>, T>.Abs(Vector256<T> vector) => Vector256.Abs(vector); 479static Vector256<T> ISimdVector<Vector256<T>, T>.Add(Vector256<T> left, Vector256<T> right) => left + right; 483static bool ISimdVector<Vector256<T>, T>.All(Vector256<T> vector, T value) => Vector256.All(vector, value); 487static bool ISimdVector<Vector256<T>, T>.AllWhereAllBitsSet(Vector256<T> vector) => Vector256.AllWhereAllBitsSet(vector); 491static Vector256<T> ISimdVector<Vector256<T>, T>.AndNot(Vector256<T> left, Vector256<T> right) => Vector256.AndNot(left, right); 495static bool ISimdVector<Vector256<T>, T>.Any(Vector256<T> vector, T value) => Vector256.Any(vector, value); 499static bool ISimdVector<Vector256<T>, T>.AnyWhereAllBitsSet(Vector256<T> vector) => Vector256.AnyWhereAllBitsSet(vector); 503static Vector256<T> ISimdVector<Vector256<T>, T>.BitwiseAnd(Vector256<T> left, Vector256<T> right) => left & right; 507static Vector256<T> ISimdVector<Vector256<T>, T>.BitwiseOr(Vector256<T> left, Vector256<T> right) => left | right; 511static Vector256<T> ISimdVector<Vector256<T>, T>.Ceiling(Vector256<T> vector) => Vector256.Ceiling(vector); 515static Vector256<T> ISimdVector<Vector256<T>, T>.Clamp(Vector256<T> value, Vector256<T> min, Vector256<T> max) => Vector256.Clamp(value, min, max); 519static Vector256<T> ISimdVector<Vector256<T>, T>.ClampNative(Vector256<T> value, Vector256<T> min, Vector256<T> max) => Vector256.ClampNative(value, min, max); 523static Vector256<T> ISimdVector<Vector256<T>, T>.ConditionalSelect(Vector256<T> condition, Vector256<T> left, Vector256<T> right) => Vector256.ConditionalSelect(condition, left, right); 527static Vector256<T> ISimdVector<Vector256<T>, T>.CopySign(Vector256<T> value, Vector256<T> sign) => Vector256.CopySign(value, sign); 530static void ISimdVector<Vector256<T>, T>.CopyTo(Vector256<T> vector, T[] destination) => vector.CopyTo(destination); 533static void ISimdVector<Vector256<T>, T>.CopyTo(Vector256<T> vector, T[] destination, int startIndex) => vector.CopyTo(destination, startIndex); 536static void ISimdVector<Vector256<T>, T>.CopyTo(Vector256<T> vector, Span<T> destination) => vector.CopyTo(destination); 540static int ISimdVector<Vector256<T>, T>.Count(Vector256<T> vector, T value) => Vector256.Count(vector, value); 544static int ISimdVector<Vector256<T>, T>.CountWhereAllBitsSet(Vector256<T> vector) => Vector256.CountWhereAllBitsSet(vector); 548static Vector256<T> ISimdVector<Vector256<T>, T>.Create(T value) => Vector256.Create(value); 551static Vector256<T> ISimdVector<Vector256<T>, T>.Create(T[] values) => Vector256.Create(values); 554static Vector256<T> ISimdVector<Vector256<T>, T>.Create(T[] values, int index) => Vector256.Create(values, index); 557static Vector256<T> ISimdVector<Vector256<T>, T>.Create(ReadOnlySpan<T> values) => Vector256.Create(values); 561static Vector256<T> ISimdVector<Vector256<T>, T>.CreateScalar(T value) => Vector256.CreateScalar(value); 565static Vector256<T> ISimdVector<Vector256<T>, T>.CreateScalarUnsafe(T value) => Vector256.CreateScalarUnsafe(value); 569static Vector256<T> ISimdVector<Vector256<T>, T>.Divide(Vector256<T> left, Vector256<T> right) => left / right; 573static Vector256<T> ISimdVector<Vector256<T>, T>.Divide(Vector256<T> left, T right) => left / right; 577static T ISimdVector<Vector256<T>, T>.Dot(Vector256<T> left, Vector256<T> right) => Vector256.Dot(left, right); 581static Vector256<T> ISimdVector<Vector256<T>, T>.Equals(Vector256<T> left, Vector256<T> right) => Vector256.Equals(left, right); 585static bool ISimdVector<Vector256<T>, T>.EqualsAll(Vector256<T> left, Vector256<T> right) => left == right; 589static bool ISimdVector<Vector256<T>, T>.EqualsAny(Vector256<T> left, Vector256<T> right) => Vector256.EqualsAny(left, right); 593static Vector256<T> ISimdVector<Vector256<T>, T>.Floor(Vector256<T> vector) => Vector256.Floor(vector); 597static T ISimdVector<Vector256<T>, T>.GetElement(Vector256<T> vector, int index) => vector.GetElement(index); 601static Vector256<T> ISimdVector<Vector256<T>, T>.GreaterThan(Vector256<T> left, Vector256<T> right) => Vector256.GreaterThan(left, right); 605static bool ISimdVector<Vector256<T>, T>.GreaterThanAll(Vector256<T> left, Vector256<T> right) => Vector256.GreaterThanAll(left, right); 609static bool ISimdVector<Vector256<T>, T>.GreaterThanAny(Vector256<T> left, Vector256<T> right) => Vector256.GreaterThanAny(left, right); 613static Vector256<T> ISimdVector<Vector256<T>, T>.GreaterThanOrEqual(Vector256<T> left, Vector256<T> right) => Vector256.GreaterThanOrEqual(left, right); 617static bool ISimdVector<Vector256<T>, T>.GreaterThanOrEqualAll(Vector256<T> left, Vector256<T> right) => Vector256.GreaterThanOrEqualAll(left, right); 621static bool ISimdVector<Vector256<T>, T>.GreaterThanOrEqualAny(Vector256<T> left, Vector256<T> right) => Vector256.GreaterThanOrEqualAny(left, right); 625static int ISimdVector<Vector256<T>, T>.IndexOf(Vector256<T> vector, T value) => Vector256.IndexOf(vector, value); 629static int ISimdVector<Vector256<T>, T>.IndexOfWhereAllBitsSet(Vector256<T> vector) => Vector256.IndexOfWhereAllBitsSet(vector); 633static Vector256<T> ISimdVector<Vector256<T>, T>.IsEvenInteger(Vector256<T> vector) => Vector256.IsEvenInteger(vector); 637static Vector256<T> ISimdVector<Vector256<T>, T>.IsFinite(Vector256<T> vector) => Vector256.IsFinite(vector); 641static Vector256<T> ISimdVector<Vector256<T>, T>.IsInfinity(Vector256<T> vector) => Vector256.IsInfinity(vector); 645static Vector256<T> ISimdVector<Vector256<T>, T>.IsInteger(Vector256<T> vector) => Vector256.IsInteger(vector); 649static Vector256<T> ISimdVector<Vector256<T>, T>.IsNaN(Vector256<T> vector) => Vector256.IsNaN(vector); 653static Vector256<T> ISimdVector<Vector256<T>, T>.IsNegative(Vector256<T> vector) => Vector256.IsNegative(vector); 657static Vector256<T> ISimdVector<Vector256<T>, T>.IsNegativeInfinity(Vector256<T> vector) => Vector256.IsNegativeInfinity(vector); 661static Vector256<T> ISimdVector<Vector256<T>, T>.IsNormal(Vector256<T> vector) => Vector256.IsNormal(vector); 665static Vector256<T> ISimdVector<Vector256<T>, T>.IsOddInteger(Vector256<T> vector) => Vector256.IsOddInteger(vector); 669static Vector256<T> ISimdVector<Vector256<T>, T>.IsPositive(Vector256<T> vector) => Vector256.IsPositive(vector); 673static Vector256<T> ISimdVector<Vector256<T>, T>.IsPositiveInfinity(Vector256<T> vector) => Vector256.IsPositiveInfinity(vector); 677static Vector256<T> ISimdVector<Vector256<T>, T>.IsSubnormal(Vector256<T> vector) => Vector256.IsSubnormal(vector); 680static Vector256<T> ISimdVector<Vector256<T>, T>.IsZero(Vector256<T> vector) => Vector256.IsZero(vector); 684static int ISimdVector<Vector256<T>, T>.LastIndexOf(Vector256<T> vector, T value) => Vector256.LastIndexOf(vector, value); 688static int ISimdVector<Vector256<T>, T>.LastIndexOfWhereAllBitsSet(Vector256<T> vector) => Vector256.LastIndexOfWhereAllBitsSet(vector); 692static Vector256<T> ISimdVector<Vector256<T>, T>.LessThan(Vector256<T> left, Vector256<T> right) => Vector256.LessThan(left, right); 696static bool ISimdVector<Vector256<T>, T>.LessThanAll(Vector256<T> left, Vector256<T> right) => Vector256.LessThanAll(left, right); 700static bool ISimdVector<Vector256<T>, T>.LessThanAny(Vector256<T> left, Vector256<T> right) => Vector256.LessThanAny(left, right); 704static Vector256<T> ISimdVector<Vector256<T>, T>.LessThanOrEqual(Vector256<T> left, Vector256<T> right) => Vector256.LessThanOrEqual(left, right); 708static bool ISimdVector<Vector256<T>, T>.LessThanOrEqualAll(Vector256<T> left, Vector256<T> right) => Vector256.LessThanOrEqualAll(left, right); 712static bool ISimdVector<Vector256<T>, T>.LessThanOrEqualAny(Vector256<T> left, Vector256<T> right) => Vector256.LessThanOrEqualAny(left, right); 716static Vector256<T> ISimdVector<Vector256<T>, T>.Load(T* source) => Vector256.Load(source); 720static Vector256<T> ISimdVector<Vector256<T>, T>.LoadAligned(T* source) => Vector256.LoadAligned(source); 724static Vector256<T> ISimdVector<Vector256<T>, T>.LoadAlignedNonTemporal(T* source) => Vector256.LoadAlignedNonTemporal(source); 728static Vector256<T> ISimdVector<Vector256<T>, T>.LoadUnsafe(ref readonly T source) => Vector256.LoadUnsafe(in source); 732static Vector256<T> ISimdVector<Vector256<T>, T>.LoadUnsafe(ref readonly T source, nuint elementOffset) => Vector256.LoadUnsafe(in source, elementOffset); 736static Vector256<T> ISimdVector<Vector256<T>, T>.Max(Vector256<T> left, Vector256<T> right) => Vector256.Max(left, right); 740static Vector256<T> ISimdVector<Vector256<T>, T>.MaxMagnitude(Vector256<T> left, Vector256<T> right) => Vector256.MaxMagnitude(left, right); 744static Vector256<T> ISimdVector<Vector256<T>, T>.MaxMagnitudeNumber(Vector256<T> left, Vector256<T> right) => Vector256.MaxMagnitudeNumber(left, right); 748static Vector256<T> ISimdVector<Vector256<T>, T>.MaxNative(Vector256<T> left, Vector256<T> right) => Vector256.MaxNative(left, right); 752static Vector256<T> ISimdVector<Vector256<T>, T>.MaxNumber(Vector256<T> left, Vector256<T> right) => Vector256.MaxNumber(left, right); 756static Vector256<T> ISimdVector<Vector256<T>, T>.Min(Vector256<T> left, Vector256<T> right) => Vector256.Min(left, right); 760static Vector256<T> ISimdVector<Vector256<T>, T>.MinMagnitude(Vector256<T> left, Vector256<T> right) => Vector256.MinMagnitude(left, right); 764static Vector256<T> ISimdVector<Vector256<T>, T>.MinMagnitudeNumber(Vector256<T> left, Vector256<T> right) => Vector256.MinMagnitudeNumber(left, right); 768static Vector256<T> ISimdVector<Vector256<T>, T>.MinNative(Vector256<T> left, Vector256<T> right) => Vector256.MinNative(left, right); 772static Vector256<T> ISimdVector<Vector256<T>, T>.MinNumber(Vector256<T> left, Vector256<T> right) => Vector256.MinNumber(left, right); 776static Vector256<T> ISimdVector<Vector256<T>, T>.Multiply(Vector256<T> left, Vector256<T> right) => left * right; 780static Vector256<T> ISimdVector<Vector256<T>, T>.Multiply(Vector256<T> left, T right) => left * right; 784static Vector256<T> ISimdVector<Vector256<T>, T>.MultiplyAddEstimate(Vector256<T> left, Vector256<T> right, Vector256<T> addend) => Vector256.MultiplyAddEstimate(left, right, addend); 788static Vector256<T> ISimdVector<Vector256<T>, T>.Negate(Vector256<T> vector) => -vector; 792static bool ISimdVector<Vector256<T>, T>.None(Vector256<T> vector, T value) => Vector256.None(vector, value); 796static bool ISimdVector<Vector256<T>, T>.NoneWhereAllBitsSet(Vector256<T> vector) => Vector256.NoneWhereAllBitsSet(vector); 800static Vector256<T> ISimdVector<Vector256<T>, T>.OnesComplement(Vector256<T> vector) => ~vector; 804static Vector256<T> ISimdVector<Vector256<T>, T>.Round(Vector256<T> vector) => Vector256.Round(vector); 808static Vector256<T> ISimdVector<Vector256<T>, T>.ShiftLeft(Vector256<T> vector, int shiftCount) => vector << shiftCount; 812static Vector256<T> ISimdVector<Vector256<T>, T>.ShiftRightArithmetic(Vector256<T> vector, int shiftCount) => vector >> shiftCount; 816static Vector256<T> ISimdVector<Vector256<T>, T>.ShiftRightLogical(Vector256<T> vector, int shiftCount) => vector >>> shiftCount; 820static Vector256<T> ISimdVector<Vector256<T>, T>.Sqrt(Vector256<T> vector) => Vector256.Sqrt(vector); 824static void ISimdVector<Vector256<T>, T>.Store(Vector256<T> source, T* destination) => source.Store(destination); 828static void ISimdVector<Vector256<T>, T>.StoreAligned(Vector256<T> source, T* destination) => source.StoreAligned(destination); 832static void ISimdVector<Vector256<T>, T>.StoreAlignedNonTemporal(Vector256<T> source, T* destination) => source.StoreAlignedNonTemporal(destination); 836static void ISimdVector<Vector256<T>, T>.StoreUnsafe(Vector256<T> vector, ref T destination) => vector.StoreUnsafe(ref destination); 840static void ISimdVector<Vector256<T>, T>.StoreUnsafe(Vector256<T> vector, ref T destination, nuint elementOffset) => vector.StoreUnsafe(ref destination, elementOffset); 844static Vector256<T> ISimdVector<Vector256<T>, T>.Subtract(Vector256<T> left, Vector256<T> right) => left - right; 848static T ISimdVector<Vector256<T>, T>.Sum(Vector256<T> vector) => Vector256.Sum(vector); 852static T ISimdVector<Vector256<T>, T>.ToScalar(Vector256<T> vector) => vector.ToScalar(); 856static Vector256<T> ISimdVector<Vector256<T>, T>.Truncate(Vector256<T> vector) => Vector256.Truncate(vector); 859static bool ISimdVector<Vector256<T>, T>.TryCopyTo(Vector256<T> vector, Span<T> destination) => vector.TryCopyTo(destination); 863static Vector256<T> ISimdVector<Vector256<T>, T>.WithElement(Vector256<T> vector, int index, T value) => vector.WithElement(index, value); 867static Vector256<T> ISimdVector<Vector256<T>, T>.Xor(Vector256<T> left, Vector256<T> right) => left ^ right;
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256.cs (1012)
57extension<T>(Vector256<T>) 61public static Vector256<T> E 68public static Vector256<T> Pi 75public static Vector256<T> Tau 83extension<T>(Vector256<T>) 87public static Vector256<T> Epsilon 94public static Vector256<T> NaN 101public static Vector256<T> NegativeInfinity 108public static Vector256<T> NegativeZero 115public static Vector256<T> PositiveInfinity 123extension<T>(Vector256<T>) 127public static Vector256<T> NegativeOne 134public static Vector256<T> SignSequence 149public static Vector256<T> Abs<T>(Vector256<T> vector) 166public static Vector256<T> Add<T>(Vector256<T> left, Vector256<T> right) => left + right; 171public static Vector256<T> AddSaturate<T>(Vector256<T> left, Vector256<T> right) 189public static bool All<T>(Vector256<T> vector, T value) => vector == Create(value); 194public static bool AllWhereAllBitsSet<T>(Vector256<T> vector) 218public static Vector256<T> AndNot<T>(Vector256<T> left, Vector256<T> right) => left & ~right; 223public static bool Any<T>(Vector256<T> vector, T value) => EqualsAny(vector, Create(value)); 228public static bool AnyWhereAllBitsSet<T>(Vector256<T> vector) 252public static Vector256<TTo> As<TFrom, TTo>(this Vector256<TFrom> vector) 257return Unsafe.BitCast<Vector256<TFrom>, Vector256<TTo>>(vector); 260/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see langword="Vector256&lt;Byte&gt;" />.</summary> 266public static Vector256<byte> AsByte<T>(this Vector256<T> vector) => vector.As<T, byte>(); 268/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see langword="Vector256&lt;Double&gt;" />.</summary> 274public static Vector256<double> AsDouble<T>(this Vector256<T> vector) => vector.As<T, double>(); 276/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see langword="Vector256&lt;Int16&gt;" />.</summary> 282public static Vector256<short> AsInt16<T>(this Vector256<T> vector) => vector.As<T, short>(); 284/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see langword="Vector256&lt;Int32&gt;" />.</summary> 290public static Vector256<int> AsInt32<T>(this Vector256<T> vector) => vector.As<T, int>(); 292/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see langword="Vector256&lt;Int64&gt;" />.</summary> 298public static Vector256<long> AsInt64<T>(this Vector256<T> vector) => vector.As<T, long>(); 300/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see langword="Vector256&lt;IntPtr&gt;" />.</summary> 306public static Vector256<nint> AsNInt<T>(this Vector256<T> vector) => vector.As<T, nint>(); 308/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see langword="Vector256&lt;UIntPtr&gt;" />.</summary> 315public static Vector256<nuint> AsNUInt<T>(this Vector256<T> vector) => vector.As<T, nuint>(); 317/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see langword="Vector256&lt;SByte&gt;" />.</summary> 324public static Vector256<sbyte> AsSByte<T>(this Vector256<T> vector) => vector.As<T, sbyte>(); 326/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see langword="Vector256&lt;Single&gt;" />.</summary> 332public static Vector256<float> AsSingle<T>(this Vector256<T> vector) => vector.As<T, float>(); 334/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see langword="Vector256&lt;UInt16&gt;" />.</summary> 341public static Vector256<ushort> AsUInt16<T>(this Vector256<T> vector) => vector.As<T, ushort>(); 343/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see langword="Vector256&lt;UInt32&gt;" />.</summary> 350public static Vector256<uint> AsUInt32<T>(this Vector256<T> vector) => vector.As<T, uint>(); 352/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see langword="Vector256&lt;UInt64&gt;" />.</summary> 359public static Vector256<ulong> AsUInt64<T>(this Vector256<T> vector) => vector.As<T, ulong>(); 361/// <summary>Reinterprets a <see cref="Vector{T}" /> as a new <see cref="Vector256{T}" />.</summary> 364/// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector256{T}" />.</returns> 368public static Vector256<T> AsVector256<T>(this Vector<T> value) 372if (Vector<T>.Count >= Vector256<T>.Count) 375return Unsafe.ReadUnaligned<Vector256<T>>(ref address); 379Vector256<T> result = default; 380Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<T>, byte>(ref result), value); 385/// <summary>Reinterprets a <see cref="Vector256{T}" /> as a new <see cref="Vector{T}" />.</summary> 392public static Vector<T> AsVector<T>(this Vector256<T> value) 396if (Vector256<T>.Count >= Vector<T>.Count) 398ref byte address = ref Unsafe.As<Vector256<T>, byte>(ref value); 416public static Vector256<T> BitwiseAnd<T>(Vector256<T> left, Vector256<T> right) => left & right; 425public static Vector256<T> BitwiseOr<T>(Vector256<T> left, Vector256<T> right) => left | right; 432internal static Vector256<T> Ceiling<T>(Vector256<T> vector) 453public static Vector256<float> Ceiling(Vector256<float> vector) => Ceiling<float>(vector); 460public static Vector256<double> Ceiling(Vector256<double> vector) => Ceiling<double>(vector); 464public static Vector256<T> Clamp<T>(Vector256<T> value, Vector256<T> min, Vector256<T> max) 472public static Vector256<T> ClampNative<T>(Vector256<T> value, Vector256<T> min, Vector256<T> max) 488public static Vector256<T> ConditionalSelect<T>(Vector256<T> condition, Vector256<T> left, Vector256<T> right) => (left & condition) | AndNot(right, condition); 495public static Vector256<double> ConvertToDouble(Vector256<long> vector) 502Vector256<int> lowerBits; 507Vector256<long> upperBits = Avx2.ShiftRightLogical(vector, 32); // Extract the 32 most significant bits of vector 510Vector256<double> result = Avx.Subtract(upperBits.AsDouble(), Create(0x45300000_80100000).AsDouble()); // Compute in double precision: (upper - (2^84 + 2^63 + 2^52)) + lower 528public static Vector256<double> ConvertToDouble(Vector256<ulong> vector) 535Vector256<uint> lowerBits; 540Vector256<ulong> upperBits = Avx2.ShiftRightLogical(vector, 32); // Extract the 32 most significant bits of vector 543Vector256<double> result = Avx.Subtract(upperBits.AsDouble(), Create(0x45300000_00100000UL).AsDouble()); // Compute in double precision: (upper - (2^84 + 2^52)) + lower 560public static Vector256<int> ConvertToInt32(Vector256<float> vector) 573public static Vector256<int> ConvertToInt32Native(Vector256<float> vector) 586public static Vector256<long> ConvertToInt64(Vector256<double> vector) 599public static Vector256<long> ConvertToInt64Native(Vector256<double> vector) 612public static Vector256<float> ConvertToSingle(Vector256<int> vector) 626public static Vector256<float> ConvertToSingle(Vector256<uint> vector) 635Vector256<int> lowerBits = Avx2.And(vector, Create(0x0000FFFFU)).AsInt32(); 636Vector256<int> upperBits = Avx2.ShiftRightLogical(vector, 16).AsInt32(); 638Vector256<float> lower = Avx.ConvertToVector256Single(lowerBits); 639Vector256<float> upper = Avx.ConvertToVector256Single(upperBits); 654Vector256<float> result = Avx.Multiply(upper, Create(65536.0f)); 673public static Vector256<uint> ConvertToUInt32(Vector256<float> vector) 687public static Vector256<uint> ConvertToUInt32Native(Vector256<float> vector) 701public static Vector256<ulong> ConvertToUInt64(Vector256<double> vector) 715public static Vector256<ulong> ConvertToUInt64Native(Vector256<double> vector) 726public static Vector256<T> CopySign<T>(Vector256<T> value, Vector256<T> sign) 734return VectorMath.CopySign<Vector256<T>, T>(value, sign); 745/// <summary>Copies a <see cref="Vector256{T}" /> to a given array.</summary> 749/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector256{T}.Count" />.</exception> 753public static void CopyTo<T>(this Vector256<T> vector, T[] destination) 757if (destination.Length < Vector256<T>.Count) 765/// <summary>Copies a <see cref="Vector256{T}" /> to a given array starting at the specified index.</summary> 770/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector256{T}.Count" />.</exception> 775public static void CopyTo<T>(this Vector256<T> vector, T[] destination, int startIndex) 784if ((destination.Length - startIndex) < Vector256<T>.Count) 792/// <summary>Copies a <see cref="Vector256{T}" /> to a given span.</summary> 796/// <exception cref="ArgumentException">The length of <paramref name="destination" /> is less than <see cref="Vector256{T}.Count" />.</exception> 799public static void CopyTo<T>(this Vector256<T> vector, Span<T> destination) 801if (destination.Length < Vector256<T>.Count) 811public static Vector256<double> Asin(Vector256<double> vector) 815return VectorMath.AsinDouble<Vector256<double>, Vector256<ulong>>(vector); 828public static Vector256<float> Asin(Vector256<float> vector) 834return VectorMath.AsinSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 838return VectorMath.AsinSingle<Vector256<float>, Vector256<int>, Vector256<double>, Vector256<long>>(vector); 852public static Vector256<double> Cos(Vector256<double> vector) 856return VectorMath.CosDouble<Vector256<double>, Vector256<long>>(vector); 869public static Vector256<float> Cos(Vector256<float> vector) 875return VectorMath.CosSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 879return VectorMath.CosSingle<Vector256<float>, Vector256<int>, Vector256<double>, Vector256<long>>(vector); 894public static int Count<T>(Vector256<T> vector, T value) => CountMatches(Equals(vector, Create(value))); 899public static int CountWhereAllBitsSet<T>(Vector256<T> vector) 915/// <summary>Creates a new <see cref="Vector256{T}" /> instance with all elements initialized to the specified value.</summary> 918/// <returns>A new <see cref="Vector256{T}" /> with all elements initialized to <paramref name="value" />.</returns> 921public static Vector256<T> Create<T>(T value) 932public static Vector256<byte> Create(byte value) => Create<byte>(value); 939public static Vector256<double> Create(double value) => Create<double>(value); 946public static Vector256<short> Create(short value) => Create<short>(value); 953public static Vector256<int> Create(int value) => Create<int>(value); 960public static Vector256<long> Create(long value) => Create<long>(value); 966public static Vector256<nint> Create(nint value) => Create<nint>(value); 973public static Vector256<nuint> Create(nuint value) => Create<nuint>(value); 981public static Vector256<sbyte> Create(sbyte value) => Create<sbyte>(value); 988public static Vector256<float> Create(float value) => Create<float>(value); 996public static Vector256<ushort> Create(ushort value) => Create<ushort>(value); 1004public static Vector256<uint> Create(uint value) => Create<uint>(value); 1012public static Vector256<ulong> Create(ulong value) => Create<ulong>(value); 1014/// <summary>Creates a new <see cref="Vector256{T}" /> from a given array.</summary> 1017/// <returns>A new <see cref="Vector256{T}" /> with its elements set to the first <see cref="Vector256{T}.Count" /> elements from <paramref name="values" />.</returns> 1018/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" /> is less than <see cref="Vector256{T}.Count" />.</exception> 1022public static Vector256<T> Create<T>(T[] values) 1026if (values.Length < Vector256<T>.Count) 1031return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref values[0])); 1034/// <summary>Creates a new <see cref="Vector256{T}" /> from a given array.</summary> 1038/// <returns>A new <see cref="Vector256{T}" /> with its elements set to the first <see cref="Vector128{T}.Count" /> elements from <paramref name="values" />.</returns> 1039/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" />, starting from <paramref name="index" />, is less than <see cref="Vector256{T}.Count" />.</exception> 1043public static Vector256<T> Create<T>(T[] values, int index) 1047if ((index < 0) || ((values.Length - index) < Vector256<T>.Count)) 1052return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref values[index])); 1055/// <summary>Creates a new <see cref="Vector256{T}" /> from a given readonly span.</summary> 1058/// <returns>A new <see cref="Vector256{T}" /> with its elements set to the first <see cref="Vector256{T}.Count" /> elements from <paramref name="values" />.</returns> 1059/// <exception cref="ArgumentOutOfRangeException">The length of <paramref name="values" /> is less than <see cref="Vector256{T}.Count" />.</exception> 1062public static Vector256<T> Create<T>(ReadOnlySpan<T> values) 1064if (values.Length < Vector256<T>.Count) 1069return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 1109public static Vector256<byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15, 1127public static Vector256<double> Create(double e0, double e1, double e2, double e3) 1156public static Vector256<short> Create(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7, short e8, short e9, short e10, short e11, short e12, short e13, short e14, short e15) 1177public static Vector256<int> Create(int e0, int e1, int e2, int e3, int e4, int e5, int e6, int e7) 1194public static Vector256<long> Create(long e0, long e1, long e2, long e3) 1240public static Vector256<sbyte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15, 1262public static Vector256<float> Create(float e0, float e1, float e2, float e3, float e4, float e5, float e6, float e7) 1292public static Vector256<ushort> Create(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7, ushort e8, ushort e9, ushort e10, ushort e11, ushort e12, ushort e13, ushort e14, ushort e15) 1314public static Vector256<uint> Create(uint e0, uint e1, uint e2, uint e3, uint e4, uint e5, uint e6, uint e7) 1332public static Vector256<ulong> Create(ulong e0, ulong e1, ulong e2, ulong e3) 1340/// <summary>Creates a new <see cref="Vector256{T}" /> instance with all 64-bit parts initialized to a specified value.</summary> 1346public static Vector256<T> Create<T>(Vector64<T> value) => Create(Vector128.Create(value, value)); 1348/// <summary>Creates a new <see cref="Vector256{T}" /> instance with the lower and upper 128-bits initialized to a specified value.</summary> 1354public static Vector256<T> Create<T>(Vector128<T> value) => Create(value, value); 1356/// <summary>Creates a new <see cref="Vector256{T}" /> instance from two <see cref="Vector128{T}" /> instances.</summary> 1360/// <returns>A new <see cref="Vector256{T}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns> 1363public static Vector256<T> Create<T>(Vector128<T> lower, Vector128<T> upper) 1367Vector256<T> result = lower.ToVector256Unsafe(); 1373Unsafe.SkipInit(out Vector256<T> result); 1386public static Vector256<byte> Create(Vector128<byte> lower, Vector128<byte> upper) => Create<byte>(lower, upper); 1393public static Vector256<double> Create(Vector128<double> lower, Vector128<double> upper) => Create<double>(lower, upper); 1399public static Vector256<short> Create(Vector128<short> lower, Vector128<short> upper) => Create<short>(lower, upper); 1406public static Vector256<int> Create(Vector128<int> lower, Vector128<int> upper) => Create<int>(lower, upper); 1412public static Vector256<long> Create(Vector128<long> lower, Vector128<long> upper) => Create<long>(lower, upper); 1418public static Vector256<nint> Create(Vector128<nint> lower, Vector128<nint> upper) => Create<nint>(lower, upper); 1425public static Vector256<nuint> Create(Vector128<nuint> lower, Vector128<nuint> upper) => Create<nuint>(lower, upper); 1432public static Vector256<sbyte> Create(Vector128<sbyte> lower, Vector128<sbyte> upper) => Create<sbyte>(lower, upper); 1439public static Vector256<float> Create(Vector128<float> lower, Vector128<float> upper) => Create<float>(lower, upper); 1446public static Vector256<ushort> Create(Vector128<ushort> lower, Vector128<ushort> upper) => Create<ushort>(lower, upper); 1454public static Vector256<uint> Create(Vector128<uint> lower, Vector128<uint> upper) => Create<uint>(lower, upper); 1461public static Vector256<ulong> Create(Vector128<ulong> lower, Vector128<ulong> upper) => Create<ulong>(lower, upper); 1463/// <summary>Creates a new <see cref="Vector256{T}" /> instance with the first element initialized to the specified value and the remaining elements initialized to zero.</summary> 1466/// <returns>A new <see cref="Vector256{T}" /> instance with the first element initialized to <paramref name="value" /> and the remaining elements initialized to zero.</returns> 1469public static Vector256<T> CreateScalar<T>(T value) => Vector128.CreateScalar(value).ToVector256(); 1475public static Vector256<byte> CreateScalar(byte value) => CreateScalar<byte>(value); 1481public static Vector256<double> CreateScalar(double value) => CreateScalar<double>(value); 1487public static Vector256<short> CreateScalar(short value) => CreateScalar<short>(value); 1493public static Vector256<int> CreateScalar(int value) => CreateScalar<int>(value); 1499public static Vector256<long> CreateScalar(long value) => CreateScalar<long>(value); 1505public static Vector256<nint> CreateScalar(nint value) => CreateScalar<nint>(value); 1512public static Vector256<nuint> CreateScalar(nuint value) => CreateScalar<nuint>(value); 1519public static Vector256<sbyte> CreateScalar(sbyte value) => CreateScalar<sbyte>(value); 1525public static Vector256<float> CreateScalar(float value) => CreateScalar<float>(value); 1532public static Vector256<ushort> CreateScalar(ushort value) => CreateScalar<ushort>(value); 1539public static Vector256<uint> CreateScalar(uint value) => CreateScalar<uint>(value); 1546public static Vector256<ulong> CreateScalar(ulong value) => CreateScalar<ulong>(value); 1548/// <summary>Creates a new <see cref="Vector256{T}" /> instance with the first element initialized to the specified value and the remaining elements left uninitialized.</summary> 1551/// <returns>A new <see cref="Vector256{T}" /> instance with the first element initialized to <paramref name="value" /> and the remaining elements left uninitialized.</returns> 1555public static Vector256<T> CreateScalarUnsafe<T>(T value) 1561Unsafe.SkipInit(out Vector256<T> result); 1571public static Vector256<byte> CreateScalarUnsafe(byte value) => CreateScalarUnsafe<byte>(value); 1577public static Vector256<double> CreateScalarUnsafe(double value) => CreateScalarUnsafe<double>(value); 1583public static Vector256<short> CreateScalarUnsafe(short value) => CreateScalarUnsafe<short>(value); 1589public static Vector256<int> CreateScalarUnsafe(int value) => CreateScalarUnsafe<int>(value); 1595public static Vector256<long> CreateScalarUnsafe(long value) => CreateScalarUnsafe<long>(value); 1601public static Vector256<nint> CreateScalarUnsafe(nint value) => CreateScalarUnsafe<nint>(value); 1608public static Vector256<nuint> CreateScalarUnsafe(nuint value) => CreateScalarUnsafe<nuint>(value); 1615public static Vector256<sbyte> CreateScalarUnsafe(sbyte value) => CreateScalarUnsafe<sbyte>(value); 1621public static Vector256<float> CreateScalarUnsafe(float value) => CreateScalarUnsafe<float>(value); 1628public static Vector256<ushort> CreateScalarUnsafe(ushort value) => CreateScalarUnsafe<ushort>(value); 1635public static Vector256<uint> CreateScalarUnsafe(uint value) => CreateScalarUnsafe<uint>(value); 1642public static Vector256<ulong> CreateScalarUnsafe(ulong value) => CreateScalarUnsafe<ulong>(value); 1644/// <summary>Creates a new <see cref="Vector256{T}" /> instance where the elements begin at a specified value and which are spaced apart according to another specified value.</summary> 1648/// <returns>A new <see cref="Vector256{T}" /> instance with the first element initialized to <paramref name="start" /> and each subsequent element initialized to the value of the previous element plus <paramref name="step" />.</returns> 1651public static Vector256<T> CreateSequence<T>(T start, T step) => (Vector256<T>.Indices * step) + Create(start); 1653/// <summary>Creates a new <see cref="Vector256{T}" /> instance where the elements begin at a specified value and are multiplied by another specified value.</summary> 1657/// <returns>A new <see cref="Vector256{T}" /> instance with each element initialized to <paramref name="initial" /> multiplied by <paramref name="multiplier" /> raised to the element index.</returns> 1661public static Vector256<T> CreateGeometricSequence<T>(T initial, [ConstantExpected] T multiplier) 1663Unsafe.SkipInit(out Vector256<T> result); 1667for (int index = 0; index < Vector256<T>.Count; index++) 1679for (int index = 1; index < Vector256<T>.Count; index++) 1688/// <summary>Creates a new <see cref="Vector256{T}" /> instance whose elements alternate between two specified values.</summary> 1692/// <returns>A new <see cref="Vector256{T}" /> instance whose even-indexed elements are initialized to <paramref name="even" /> and odd-indexed elements are initialized to <paramref name="odd" />.</returns> 1696public static Vector256<T> CreateAlternatingSequence<T>(T even, T odd) 1702/// <summary>Creates a new <see cref="Vector256{T}" /> instance whose elements are the reciprocal of an arithmetic sequence.</summary> 1706/// <returns>A new <see cref="Vector256{T}" /> instance whose elements are initialized to one divided by the corresponding element of the arithmetic sequence.</returns> 1710public static Vector256<T> CreateHarmonicSequence<T>(T start, T step) 1714return Vector256<T>.One / CreateSequence(start, step); 1728public static Vector256<T> ConcatLowerLower<T>(Vector256<T> left, Vector256<T> right) => Create(left.GetLower(), right.GetLower()); 1733public static Vector256<T> ConcatUpperLower<T>(Vector256<T> left, Vector256<T> right) => Create(left.GetUpper(), right.GetLower()); 1738public static Vector256<T> ConcatUpperUpper<T>(Vector256<T> left, Vector256<T> right) => Create(left.GetUpper(), right.GetUpper()); 1743public static Vector256<T> ConcatLowerUpper<T>(Vector256<T> left, Vector256<T> right) => Create(left.GetLower(), right.GetUpper()); 1748public static Vector256<T> ZipLower<T>(Vector256<T> left, Vector256<T> right) => Create( 1756public static Vector256<T> ZipUpper<T>(Vector256<T> left, Vector256<T> right) => Create( 1764public static (Vector256<T> Lower, Vector256<T> Upper) Zip<T>(Vector256<T> left, Vector256<T> right) 1768Vector256<int> lower = Avx2.UnpackLow(left.AsInt32(), right.AsInt32()); 1769Vector256<int> upper = Avx2.UnpackHigh(left.AsInt32(), right.AsInt32()); 1783public static Vector256<T> UnzipEven<T>(Vector256<T> left, Vector256<T> right) => Create( 1791public static Vector256<T> UnzipOdd<T>(Vector256<T> left, Vector256<T> right) => Create( 1799public static (Vector256<T> Even, Vector256<T> Odd) Unzip<T>(Vector256<T> left, Vector256<T> right) 1803Vector256<int> leftUnzip = Avx2.Shuffle(left.AsInt32(), 0xD8); 1806Vector256<int> rightUnzip = Avx2.Shuffle(right.AsInt32(), 0xD8); 1821public static Vector256<T> Reverse<T>(Vector256<T> vector) => Create( 1829public static Vector256<double> DegreesToRadians(Vector256<double> degrees) 1833return VectorMath.DegreesToRadiansDouble<Vector256<double>, Vector256<ulong>>(degrees); 1847public static Vector256<float> DegreesToRadians(Vector256<float> degrees) 1853return VectorMath.DegreesToRadiansSingle<Vector256<float>, Vector512<double>>(degrees); 1857return VectorMath.DegreesToRadiansSingle<Vector256<float>, Vector256<double>>(degrees); 1876public static Vector256<T> Divide<T>(Vector256<T> left, Vector256<T> right) => left / right; 1884public static Vector256<T> Divide<T>(Vector256<T> left, T right) => left / right; 1894public static T Dot<T>(Vector256<T> left, Vector256<T> right) => Sum(left * right); 1904public static Vector256<T> Equals<T>(Vector256<T> left, Vector256<T> right) 1919public static bool EqualsAll<T>(Vector256<T> left, Vector256<T> right) => left == right; 1929public static bool EqualsAny<T>(Vector256<T> left, Vector256<T> right) 1937public static Vector256<double> Exp(Vector256<double> vector) 1941return VectorMath.ExpDouble<Vector256<double>, Vector256<ulong>>(vector); 1954public static Vector256<float> Exp(Vector256<float> vector) 1960return VectorMath.ExpSingle<Vector256<float>, Vector256<uint>, Vector512<double>, Vector512<ulong>>(vector); 1964return VectorMath.ExpSingle<Vector256<float>, Vector256<uint>, Vector256<double>, Vector256<ulong>>(vector); 1984public static uint ExtractMostSignificantBits<T>(this Vector256<T> vector) 1996internal static Vector256<T> Floor<T>(Vector256<T> vector) 2017public static Vector256<float> Floor(Vector256<float> vector) => Floor<float>(vector); 2024public static Vector256<double> Floor(Vector256<double> vector) => Floor<double>(vector); 2029public static Vector256<double> FusedMultiplyAdd(Vector256<double> left, Vector256<double> right, Vector256<double> addend) 2040public static Vector256<float> FusedMultiplyAdd(Vector256<float> left, Vector256<float> right, Vector256<float> addend) 2057public static T GetElement<T>(this Vector256<T> vector, int index) 2059if ((uint)(index) >= (uint)(Vector256<T>.Count)) 2073public static Vector128<T> GetLower<T>(this Vector256<T> vector) 2085public static Vector128<T> GetUpper<T>(this Vector256<T> vector) 2099public static Vector256<T> GreaterThan<T>(Vector256<T> left, Vector256<T> right) 2115public static bool GreaterThanAll<T>(Vector256<T> left, Vector256<T> right) 2129public static bool GreaterThanAny<T>(Vector256<T> left, Vector256<T> right) 2143public static Vector256<T> GreaterThanOrEqual<T>(Vector256<T> left, Vector256<T> right) 2159public static bool GreaterThanOrEqualAll<T>(Vector256<T> left, Vector256<T> right) 2173public static bool GreaterThanOrEqualAny<T>(Vector256<T> left, Vector256<T> right) 2181public static Vector256<double> Hypot(Vector256<double> x, Vector256<double> y) 2185return VectorMath.HypotDouble<Vector256<double>, Vector256<ulong>>(x, y); 2198public static Vector256<float> Hypot(Vector256<float> x, Vector256<float> y) 2204return VectorMath.HypotSingle<Vector256<float>, Vector512<double>>(x, y); 2208return VectorMath.HypotSingle<Vector256<float>, Vector256<double>>(x, y); 2223public static int IndexOf<T>(Vector256<T> vector, T value) => IndexOfFirstMatch(Equals(vector, Create(value))); 2228public static int IndexOfWhereAllBitsSet<T>(Vector256<T> vector) 2247public static Vector256<T> IsEvenInteger<T>(Vector256<T> vector) 2251return VectorMath.IsEvenIntegerSingle<Vector256<float>, Vector256<uint>>(vector.AsSingle()).As<float, T>(); 2255return VectorMath.IsEvenIntegerDouble<Vector256<double>, Vector256<ulong>>(vector.AsDouble()).As<double, T>(); 2257return IsZero(vector & Vector256<T>.One); 2263public static Vector256<T> IsFinite<T>(Vector256<T> vector) 2267return ~IsZero(AndNot(Vector256<float>.PositiveInfinity.AsUInt32(), vector.AsUInt32())).As<uint, T>(); 2271return ~IsZero(AndNot(Vector256<double>.PositiveInfinity.AsUInt64(), vector.AsUInt64())).As<ulong, T>(); 2273return Vector256<T>.AllBitsSet; 2279public static Vector256<T> IsInfinity<T>(Vector256<T> vector) 2285return Vector256<T>.Zero; 2291public static Vector256<T> IsInteger<T>(Vector256<T> vector) 2297return Vector256<T>.AllBitsSet; 2303public static Vector256<T> IsNaN<T>(Vector256<T> vector) 2309return Vector256<T>.Zero; 2315public static Vector256<T> IsNegative<T>(Vector256<T> vector) 2319return Vector256<T>.Zero; 2323return LessThan(vector.AsInt32(), Vector256<int>.Zero).As<int, T>(); 2327return LessThan(vector.AsInt64(), Vector256<long>.Zero).As<long, T>(); 2331return LessThan(vector, Vector256<T>.Zero); 2338public static Vector256<T> IsNegativeInfinity<T>(Vector256<T> vector) 2342return Equals(vector, Vector256<float>.NegativeInfinity.As<float, T>()); 2346return Equals(vector, Vector256<double>.NegativeInfinity.As<double, T>()); 2348return Vector256<T>.Zero; 2354public static Vector256<T> IsNormal<T>(Vector256<T> vector) 2370public static Vector256<T> IsOddInteger<T>(Vector256<T> vector) 2374return VectorMath.IsOddIntegerSingle<Vector256<float>, Vector256<uint>>(vector.AsSingle()).As<float, T>(); 2378return VectorMath.IsOddIntegerDouble<Vector256<double>, Vector256<ulong>>(vector.AsDouble()).As<double, T>(); 2380return ~IsZero(vector & Vector256<T>.One); 2386public static Vector256<T> IsPositive<T>(Vector256<T> vector) 2390return Vector256<T>.AllBitsSet; 2394return GreaterThanOrEqual(vector.AsInt32(), Vector256<int>.Zero).As<int, T>(); 2398return GreaterThanOrEqual(vector.AsInt64(), Vector256<long>.Zero).As<long, T>(); 2402return GreaterThanOrEqual(vector, Vector256<T>.Zero); 2409public static Vector256<T> IsPositiveInfinity<T>(Vector256<T> vector) 2413return Equals(vector, Vector256<float>.PositiveInfinity.As<float, T>()); 2417return Equals(vector, Vector256<double>.PositiveInfinity.As<double, T>()); 2419return Vector256<T>.Zero; 2425public static Vector256<T> IsSubnormal<T>(Vector256<T> vector) 2429return LessThan(Abs(vector).AsUInt32() - Vector256<uint>.One, Create<uint>(float.MaxTrailingSignificand)).As<uint, T>(); 2433return LessThan(Abs(vector).AsUInt64() - Vector256<ulong>.One, Create<ulong>(double.MaxTrailingSignificand)).As<ulong, T>(); 2435return Vector256<T>.Zero; 2441public static Vector256<T> IsZero<T>(Vector256<T> vector) => Equals(vector, Vector256<T>.Zero); 2446public static int LastIndexOf<T>(Vector256<T> vector, T value) => IndexOfLastMatch(Equals(vector, Create(value))); 2451public static int LastIndexOfWhereAllBitsSet<T>(Vector256<T> vector) 2470public static Vector256<double> Lerp(Vector256<double> x, Vector256<double> y, Vector256<double> amount) 2474return VectorMath.Lerp<Vector256<double>, double>(x, y, amount); 2488public static Vector256<float> Lerp(Vector256<float> x, Vector256<float> y, Vector256<float> amount) 2492return VectorMath.Lerp<Vector256<float>, float>(x, y, amount); 2511public static Vector256<T> LessThan<T>(Vector256<T> left, Vector256<T> right) 2527public static bool LessThanAll<T>(Vector256<T> left, Vector256<T> right) 2541public static bool LessThanAny<T>(Vector256<T> left, Vector256<T> right) 2555public static Vector256<T> LessThanOrEqual<T>(Vector256<T> left, Vector256<T> right) 2571public static bool LessThanOrEqualAll<T>(Vector256<T> left, Vector256<T> right) 2585public static bool LessThanOrEqualAny<T>(Vector256<T> left, Vector256<T> right) 2598public static unsafe Vector256<T> Load<T>(T* source) => LoadUnsafe(ref *source); 2608public static unsafe Vector256<T> LoadAligned<T>(T* source) 2617return *(Vector256<T>*)(source); 2628public static unsafe Vector256<T> LoadAlignedNonTemporal<T>(T* source) => LoadAligned(source); 2637public static Vector256<T> LoadUnsafe<T>(ref readonly T source) 2641return Unsafe.ReadUnaligned<Vector256<T>>(in address); 2653public static Vector256<T> LoadUnsafe<T>(ref readonly T source, nuint elementOffset) 2657return Unsafe.ReadUnaligned<Vector256<T>>(in address); 2663internal static Vector256<ushort> LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source)); 2669internal static Vector256<ushort> LoadUnsafe(ref char source, nuint elementOffset) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source), elementOffset); 2673public static Vector256<double> Log(Vector256<double> vector) 2677return VectorMath.LogDouble<Vector256<double>, Vector256<long>, Vector256<ulong>>(vector); 2690public static Vector256<float> Log(Vector256<float> vector) 2694return VectorMath.LogSingle<Vector256<float>, Vector256<int>, Vector256<uint>>(vector); 2707public static Vector256<double> Log2(Vector256<double> vector) 2711return VectorMath.Log2Double<Vector256<double>, Vector256<long>, Vector256<ulong>>(vector); 2724public static Vector256<float> Log2(Vector256<float> vector) 2728return VectorMath.Log2Single<Vector256<float>, Vector256<int>, Vector256<uint>>(vector); 2742public static Vector256<T> Max<T>(Vector256<T> left, Vector256<T> right) 2746return VectorMath.Max<Vector256<T>, T>(left, right); 2760public static Vector256<T> MaxMagnitude<T>(Vector256<T> left, Vector256<T> right) 2764return VectorMath.MaxMagnitude<Vector256<T>, T>(left, right); 2778public static Vector256<T> MaxMagnitudeNumber<T>(Vector256<T> left, Vector256<T> right) 2782return VectorMath.MaxMagnitudeNumber<Vector256<T>, T>(left, right); 2796public static Vector256<T> MaxNative<T>(Vector256<T> left, Vector256<T> right) 2814public static Vector256<T> MaxNumber<T>(Vector256<T> left, Vector256<T> right) 2818return VectorMath.MaxNumber<Vector256<T>, T>(left, right); 2832public static Vector256<T> Min<T>(Vector256<T> left, Vector256<T> right) 2836return VectorMath.Min<Vector256<T>, T>(left, right); 2850public static Vector256<T> MinMagnitude<T>(Vector256<T> left, Vector256<T> right) 2854return VectorMath.MinMagnitude<Vector256<T>, T>(left, right); 2868public static Vector256<T> MinMagnitudeNumber<T>(Vector256<T> left, Vector256<T> right) 2872return VectorMath.MinMagnitudeNumber<Vector256<T>, T>(left, right); 2886public static Vector256<T> MinNative<T>(Vector256<T> left, Vector256<T> right) 2904public static Vector256<T> MinNumber<T>(Vector256<T> left, Vector256<T> right) 2908return VectorMath.MinNumber<Vector256<T>, T>(left, right); 2926public static Vector256<T> Multiply<T>(Vector256<T> left, Vector256<T> right) => left * right; 2935public static Vector256<T> Multiply<T>(Vector256<T> left, T right) => left * right; 2944public static Vector256<T> Multiply<T>(T left, Vector256<T> right) => right * left; 2948internal static Vector256<T> MultiplyAddEstimate<T>(Vector256<T> left, Vector256<T> right, Vector256<T> addend) 2959public static Vector256<double> MultiplyAddEstimate(Vector256<double> left, Vector256<double> right, Vector256<double> addend) 2970public static Vector256<float> MultiplyAddEstimate(Vector256<float> left, Vector256<float> right, Vector256<float> addend) 2980internal static Vector256<TResult> Narrow<TSource, TResult>(Vector256<TSource> lower, Vector256<TSource> upper) 2984Unsafe.SkipInit(out Vector256<TResult> result); 2986for (int i = 0; i < Vector256<TSource>.Count; i++) 2992for (int i = Vector256<TSource>.Count; i < Vector256<TResult>.Count; i++) 2994TResult value = TResult.CreateTruncating(upper.GetElementUnsafe(i - Vector256<TSource>.Count)); 3004public static Vector256<float> Narrow(Vector256<double> lower, Vector256<double> upper) 3011public static Vector256<sbyte> Narrow(Vector256<short> lower, Vector256<short> upper) 3017public static Vector256<short> Narrow(Vector256<int> lower, Vector256<int> upper) 3023public static Vector256<int> Narrow(Vector256<long> lower, Vector256<long> upper) 3030public static Vector256<byte> Narrow(Vector256<ushort> lower, Vector256<ushort> upper) 3037public static Vector256<ushort> Narrow(Vector256<uint> lower, Vector256<uint> upper) 3044public static Vector256<uint> Narrow(Vector256<ulong> lower, Vector256<ulong> upper) 3049internal static Vector256<TResult> NarrowWithSaturation<TSource, TResult>(Vector256<TSource> lower, Vector256<TSource> upper) 3053Unsafe.SkipInit(out Vector256<TResult> result); 3055for (int i = 0; i < Vector256<TSource>.Count; i++) 3061for (int i = Vector256<TSource>.Count; i < Vector256<TResult>.Count; i++) 3063TResult value = TResult.CreateSaturating(upper.GetElementUnsafe(i - Vector256<TSource>.Count)); 3073public static Vector256<float> NarrowWithSaturation(Vector256<double> lower, Vector256<double> upper) 3080public static Vector256<sbyte> NarrowWithSaturation(Vector256<short> lower, Vector256<short> upper) 3086public static Vector256<short> NarrowWithSaturation(Vector256<int> lower, Vector256<int> upper) 3092public static Vector256<int> NarrowWithSaturation(Vector256<long> lower, Vector256<long> upper) 3099public static Vector256<byte> NarrowWithSaturation(Vector256<ushort> lower, Vector256<ushort> upper) 3106public static Vector256<ushort> NarrowWithSaturation(Vector256<uint> lower, Vector256<uint> upper) 3113public static Vector256<uint> NarrowWithSaturation(Vector256<ulong> lower, Vector256<ulong> upper) 3122public static Vector256<T> Negate<T>(Vector256<T> vector) => -vector; 3127public static bool None<T>(Vector256<T> vector, T value) => !EqualsAny(vector, Create(value)); 3132public static bool NoneWhereAllBitsSet<T>(Vector256<T> vector) 3154public static Vector256<T> OnesComplement<T>(Vector256<T> vector) => ~vector; 3159public static Vector256<double> RadiansToDegrees(Vector256<double> radians) 3163return VectorMath.RadiansToDegreesDouble<Vector256<double>, Vector256<ulong>>(radians); 3177public static Vector256<float> RadiansToDegrees(Vector256<float> radians) 3183return VectorMath.RadiansToDegreesSingle<Vector256<float>, Vector512<double>>(radians); 3187return VectorMath.RadiansToDegreesSingle<Vector256<float>, Vector256<double>>(radians); 3201internal static Vector256<T> Round<T>(Vector256<T> vector) 3219public static Vector256<double> Round(Vector256<double> vector) => Round<double>(vector); 3223public static Vector256<float> Round(Vector256<float> vector) => Round<float>(vector); 3227public static Vector256<double> Round(Vector256<double> vector, MidpointRounding mode) => VectorMath.RoundDouble(vector, mode); 3231public static Vector256<float> Round(Vector256<float> vector, MidpointRounding mode) => VectorMath.RoundSingle(vector, mode); 3238internal static Vector256<T> ShiftLeft<T>(Vector256<T> vector, int shiftCount) => vector << shiftCount; 3245public static Vector256<byte> ShiftLeft(Vector256<byte> vector, int shiftCount) => vector << shiftCount; 3252public static Vector256<short> ShiftLeft(Vector256<short> vector, int shiftCount) => vector << shiftCount; 3259public static Vector256<int> ShiftLeft(Vector256<int> vector, int shiftCount) => vector << shiftCount; 3266public static Vector256<long> ShiftLeft(Vector256<long> vector, int shiftCount) => vector << shiftCount; 3273public static Vector256<nint> ShiftLeft(Vector256<nint> vector, int shiftCount) => vector << shiftCount; 3281public static Vector256<nuint> ShiftLeft(Vector256<nuint> vector, int shiftCount) => vector << shiftCount; 3289public static Vector256<sbyte> ShiftLeft(Vector256<sbyte> vector, int shiftCount) => vector << shiftCount; 3297public static Vector256<ushort> ShiftLeft(Vector256<ushort> vector, int shiftCount) => vector << shiftCount; 3305public static Vector256<uint> ShiftLeft(Vector256<uint> vector, int shiftCount) => vector << shiftCount; 3308internal static Vector256<uint> ShiftLeft(Vector256<uint> vector, Vector256<uint> shiftCount) 3322public static Vector256<ulong> ShiftLeft(Vector256<ulong> vector, int shiftCount) => vector << shiftCount; 3325internal static Vector256<ulong> ShiftLeft(Vector256<ulong> vector, Vector256<ulong> shiftCount) 3338internal static Vector256<T> ShiftRightArithmetic<T>(Vector256<T> vector, int shiftCount) => vector >> shiftCount; 3345public static Vector256<short> ShiftRightArithmetic(Vector256<short> vector, int shiftCount) => vector >> shiftCount; 3352public static Vector256<int> ShiftRightArithmetic(Vector256<int> vector, int shiftCount) => vector >> shiftCount; 3359public static Vector256<long> ShiftRightArithmetic(Vector256<long> vector, int shiftCount) => vector >> shiftCount; 3366public static Vector256<nint> ShiftRightArithmetic(Vector256<nint> vector, int shiftCount) => vector >> shiftCount; 3374public static Vector256<sbyte> ShiftRightArithmetic(Vector256<sbyte> vector, int shiftCount) => vector >> shiftCount; 3381internal static Vector256<T> ShiftRightLogical<T>(Vector256<T> vector, int shiftCount) => vector >>> shiftCount; 3388public static Vector256<byte> ShiftRightLogical(Vector256<byte> vector, int shiftCount) => vector >>> shiftCount; 3395public static Vector256<short> ShiftRightLogical(Vector256<short> vector, int shiftCount) => vector >>> shiftCount; 3402public static Vector256<int> ShiftRightLogical(Vector256<int> vector, int shiftCount) => vector >>> shiftCount; 3409public static Vector256<long> ShiftRightLogical(Vector256<long> vector, int shiftCount) => vector >>> shiftCount; 3416public static Vector256<nint> ShiftRightLogical(Vector256<nint> vector, int shiftCount) => vector >>> shiftCount; 3424public static Vector256<nuint> ShiftRightLogical(Vector256<nuint> vector, int shiftCount) => vector >>> shiftCount; 3432public static Vector256<sbyte> ShiftRightLogical(Vector256<sbyte> vector, int shiftCount) => vector >>> shiftCount; 3440public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> vector, int shiftCount) => vector >>> shiftCount; 3448public static Vector256<uint> ShiftRightLogical(Vector256<uint> vector, int shiftCount) => vector >>> shiftCount; 3456public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> vector, int shiftCount) => vector >>> shiftCount; 3458private static Vector256<T> ShuffleFallback<T, TIndex>(Vector256<T> vector, Vector256<TIndex> indices) 3461Debug.Assert(Vector256<T>.Count == Vector256<TIndex>.Count); 3462Vector256<T> result = Vector256<T>.Zero; 3464for (int index = 0; index < Vector256<T>.Count; index++) 3468if ((uint)selectedIndex < (uint)Vector256<T>.Count) 3482private static Vector256<T> ShuffleNativeFallback<T, TIndex>(Vector256<T> vector, Vector256<TIndex> indices) 3493public static Vector256<byte> Shuffle(Vector256<byte> vector, Vector256<byte> indices) => ShuffleFallback(vector, indices); 3495/// <inheritdoc cref="Shuffle(Vector256{byte}, Vector256{byte})" /> 3497public static Vector256<double> Shuffle(Vector256<double> vector, Vector256<long> indices) => ShuffleFallback(vector, indices); 3499/// <inheritdoc cref="Shuffle(Vector256{byte}, Vector256{byte})" /> 3501public static Vector256<short> Shuffle(Vector256<short> vector, Vector256<short> indices) => ShuffleFallback(vector, indices); 3503/// <inheritdoc cref="Shuffle(Vector256{byte}, Vector256{byte})" /> 3505public static Vector256<int> Shuffle(Vector256<int> vector, Vector256<int> indices) => ShuffleFallback(vector, indices); 3507/// <inheritdoc cref="Shuffle(Vector256{byte}, Vector256{byte})" /> 3509public static Vector256<long> Shuffle(Vector256<long> vector, Vector256<long> indices) => ShuffleFallback(vector, indices); 3511/// <inheritdoc cref="Shuffle(Vector256{byte}, Vector256{byte})" /> 3513public static Vector256<nint> Shuffle(Vector256<nint> vector, Vector256<nint> indices) => ShuffleFallback(vector, indices); 3515/// <inheritdoc cref="Shuffle(Vector256{byte}, Vector256{byte})" /> 3518public static Vector256<sbyte> Shuffle(Vector256<sbyte> vector, Vector256<sbyte> indices) => ShuffleFallback(vector, indices); 3520/// <inheritdoc cref="Shuffle(Vector256{byte}, Vector256{byte})" /> 3522public static Vector256<float> Shuffle(Vector256<float> vector, Vector256<int> indices) => ShuffleFallback(vector, indices); 3524/// <inheritdoc cref="Shuffle(Vector256{byte}, Vector256{byte})" /> 3527public static Vector256<ushort> Shuffle(Vector256<ushort> vector, Vector256<ushort> indices) => ShuffleFallback(vector, indices); 3529/// <inheritdoc cref="Shuffle(Vector256{byte}, Vector256{byte})" /> 3532public static Vector256<uint> Shuffle(Vector256<uint> vector, Vector256<uint> indices) => ShuffleFallback(vector, indices); 3534/// <inheritdoc cref="Shuffle(Vector256{byte}, Vector256{byte})" /> 3537public static Vector256<ulong> Shuffle(Vector256<ulong> vector, Vector256<ulong> indices) => ShuffleFallback(vector, indices); 3539/// <inheritdoc cref="Shuffle(Vector256{byte}, Vector256{byte})" /> 3542public static Vector256<nuint> Shuffle(Vector256<nuint> vector, Vector256<nuint> indices) => ShuffleFallback(vector, indices); 3551public static Vector256<byte> ShuffleNative(Vector256<byte> vector, Vector256<byte> indices) => ShuffleNativeFallback(vector, indices); 3553/// <inheritdoc cref="ShuffleNative(Vector256{byte}, Vector256{byte})" /> 3556public static Vector256<double> ShuffleNative(Vector256<double> vector, Vector256<long> indices) => ShuffleNativeFallback(vector, indices); 3558/// <inheritdoc cref="ShuffleNative(Vector256{byte}, Vector256{byte})" /> 3561public static Vector256<short> ShuffleNative(Vector256<short> vector, Vector256<short> indices) => ShuffleNativeFallback(vector, indices); 3563/// <inheritdoc cref="ShuffleNative(Vector256{byte}, Vector256{byte})" /> 3566public static Vector256<int> ShuffleNative(Vector256<int> vector, Vector256<int> indices) => ShuffleNativeFallback(vector, indices); 3568/// <inheritdoc cref="ShuffleNative(Vector256{byte}, Vector256{byte})" /> 3571public static Vector256<long> ShuffleNative(Vector256<long> vector, Vector256<long> indices) => ShuffleNativeFallback(vector, indices); 3573/// <inheritdoc cref="ShuffleNative(Vector256{byte}, Vector256{byte})" /> 3576public static Vector256<nint> ShuffleNative(Vector256<nint> vector, Vector256<nint> indices) => ShuffleNativeFallback(vector, indices); 3578/// <inheritdoc cref="ShuffleNative(Vector256{byte}, Vector256{byte})" /> 3582public static Vector256<sbyte> ShuffleNative(Vector256<sbyte> vector, Vector256<sbyte> indices) => ShuffleNativeFallback(vector, indices); 3584/// <inheritdoc cref="ShuffleNative(Vector256{byte}, Vector256{byte})" /> 3587public static Vector256<float> ShuffleNative(Vector256<float> vector, Vector256<int> indices) => ShuffleNativeFallback(vector, indices); 3589/// <inheritdoc cref="ShuffleNative(Vector256{byte}, Vector256{byte})" /> 3593public static Vector256<ushort> ShuffleNative(Vector256<ushort> vector, Vector256<ushort> indices) => ShuffleNativeFallback(vector, indices); 3595/// <inheritdoc cref="ShuffleNative(Vector256{byte}, Vector256{byte})" /> 3599public static Vector256<uint> ShuffleNative(Vector256<uint> vector, Vector256<uint> indices) => ShuffleNativeFallback(vector, indices); 3601/// <inheritdoc cref="ShuffleNative(Vector256{byte}, Vector256{byte})" /> 3605public static Vector256<ulong> ShuffleNative(Vector256<ulong> vector, Vector256<ulong> indices) => ShuffleNativeFallback(vector, indices); 3607/// <inheritdoc cref="ShuffleNative(Vector256{byte}, Vector256{byte})" /> 3611public static Vector256<nuint> ShuffleNative(Vector256<nuint> vector, Vector256<nuint> indices) => ShuffleNativeFallback(vector, indices); 3615public static Vector256<double> Sin(Vector256<double> vector) 3619return VectorMath.SinDouble<Vector256<double>, Vector256<long>>(vector); 3632public static Vector256<float> Sin(Vector256<float> vector) 3638return VectorMath.SinSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 3642return VectorMath.SinSingle<Vector256<float>, Vector256<int>, Vector256<double>, Vector256<long>>(vector); 3656public static (Vector256<double> Sin, Vector256<double> Cos) SinCos(Vector256<double> vector) 3660return VectorMath.SinCosDouble<Vector256<double>, Vector256<long>>(vector); 3676public static (Vector256<float> Sin, Vector256<float> Cos) SinCos(Vector256<float> vector) 3682return VectorMath.SinCosSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector); 3686return VectorMath.SinCosSingle<Vector256<float>, Vector256<int>, Vector256<double>, Vector256<long>>(vector); 3708public static Vector256<T> Sqrt<T>(Vector256<T> vector) 3723public static unsafe void Store<T>(this Vector256<T> source, T* destination) => source.StoreUnsafe(ref *destination); 3733public static unsafe void StoreAligned<T>(this Vector256<T> source, T* destination) 3742*(Vector256<T>*)(destination) = source; 3753public static unsafe void StoreAlignedNonTemporal<T>(this Vector256<T> source, T* destination) => source.StoreAligned(destination); 3762public static void StoreUnsafe<T>(this Vector256<T> source, ref T destination) 3778public static void StoreUnsafe<T>(this Vector256<T> source, ref T destination, nuint elementOffset) 3787public static Vector256<T> Subtract<T>(Vector256<T> left, Vector256<T> right) => left - right; 3792public static Vector256<T> SubtractSaturate<T>(Vector256<T> left, Vector256<T> right) 3814public static T Sum<T>(Vector256<T> vector) 3831public static T ToScalar<T>(this Vector256<T> vector) 3843public static Vector512<T> ToVector512<T>(this Vector256<T> vector) 3858public static Vector512<T> ToVector512Unsafe<T>(this Vector256<T> vector) 3872internal static Vector256<T> Truncate<T>(Vector256<T> vector) 3890public static Vector256<double> Truncate(Vector256<double> vector) => Truncate<double>(vector); 3894public static Vector256<float> Truncate(Vector256<float> vector) => Truncate<float>(vector); 3900/// <returns><c>true</c> if <paramref name="vector" /> was successfully copied to <paramref name="destination" />; otherwise, <c>false</c> if the length of <paramref name="destination" /> is less than <see cref="Vector256{T}.Count" />.</returns> 3903public static bool TryCopyTo<T>(this Vector256<T> vector, Span<T> destination) 3905if (destination.Length < Vector256<T>.Count) 3914/// <summary>Widens a <see langword="Vector256&lt;Byte&gt;" /> into two <see cref="Vector256{UInt16} " />.</summary> 3919public static (Vector256<ushort> Lower, Vector256<ushort> Upper) Widen(Vector256<byte> source) => (WidenLower(source), WidenUpper(source)); 3921/// <summary>Widens a <see langword="Vector256&lt;Int16&gt;" /> into two <see cref="Vector256{Int32} " />.</summary> 3925public static (Vector256<int> Lower, Vector256<int> Upper) Widen(Vector256<short> source) => (WidenLower(source), WidenUpper(source)); 3927/// <summary>Widens a <see langword="Vector256&lt;Int32&gt;" /> into two <see cref="Vector256{Int64} " />.</summary> 3931public static (Vector256<long> Lower, Vector256<long> Upper) Widen(Vector256<int> source) => (WidenLower(source), WidenUpper(source)); 3933/// <summary>Widens a <see langword="Vector256&lt;SByte&gt;" /> into two <see cref="Vector256{Int16} " />.</summary> 3938public static (Vector256<short> Lower, Vector256<short> Upper) Widen(Vector256<sbyte> source) => (WidenLower(source), WidenUpper(source)); 3940/// <summary>Widens a <see langword="Vector256&lt;Single&gt;" /> into two <see cref="Vector256{Double} " />.</summary> 3944public static (Vector256<double> Lower, Vector256<double> Upper) Widen(Vector256<float> source) => (WidenLower(source), WidenUpper(source)); 3946/// <summary>Widens a <see langword="Vector256&lt;UInt16&gt;" /> into two <see cref="Vector256{UInt32} " />.</summary> 3951public static (Vector256<uint> Lower, Vector256<uint> Upper) Widen(Vector256<ushort> source) => (WidenLower(source), WidenUpper(source)); 3953/// <summary>Widens a <see langword="Vector256&lt;UInt32&gt;" /> into two <see cref="Vector256{UInt64} " />.</summary> 3958public static (Vector256<ulong> Lower, Vector256<ulong> Upper) Widen(Vector256<uint> source) => (WidenLower(source), WidenUpper(source)); 3960/// <summary>Widens the lower half of a <see langword="Vector256&lt;Byte&gt;" /> into a <see cref="Vector256{UInt16} " />.</summary> 3966public static Vector256<ushort> WidenLower(Vector256<byte> source) 3976/// <summary>Widens the lower half of a <see langword="Vector256&lt;Int16&gt;" /> into a <see cref="Vector256{Int32} " />.</summary> 3981public static Vector256<int> WidenLower(Vector256<short> source) 3991/// <summary>Widens the lower half of a <see langword="Vector256&lt;Int32&gt;" /> into a <see cref="Vector256{Int64} " />.</summary> 3996public static Vector256<long> WidenLower(Vector256<int> source) 4006/// <summary>Widens the lower half of a <see langword="Vector256&lt;SByte&gt;" /> into a <see cref="Vector256{Int16} " />.</summary> 4012public static Vector256<short> WidenLower(Vector256<sbyte> source) 4021/// <summary>Widens the lower half of a <see langword="Vector256&lt;Single&gt;" /> into a <see cref="Vector256{Double} " />.</summary> 4026public static Vector256<double> WidenLower(Vector256<float> source) 4036/// <summary>Widens the lower half of a <see langword="Vector256&lt;UInt16&gt;" /> into a <see cref="Vector256{UInt32} " />.</summary> 4042public static Vector256<uint> WidenLower(Vector256<ushort> source) 4052/// <summary>Widens the lower half of a <see langword="Vector256&lt;UInt32&gt;" /> into a <see cref="Vector256{UInt64} " />.</summary> 4058public static Vector256<ulong> WidenLower(Vector256<uint> source) 4068/// <summary>Widens the upper half of a <see langword="Vector256&lt;Byte&gt;" /> into a <see cref="Vector256{UInt16} " />.</summary> 4074public static Vector256<ushort> WidenUpper(Vector256<byte> source) 4084/// <summary>Widens the upper half of a <see langword="Vector256&lt;Int16&gt;" /> into a <see cref="Vector256{Int32} " />.</summary> 4089public static Vector256<int> WidenUpper(Vector256<short> source) 4099/// <summary>Widens the upper half of a <see langword="Vector256&lt;Int32&gt;" /> into a <see cref="Vector256{Int64} " />.</summary> 4104public static Vector256<long> WidenUpper(Vector256<int> source) 4114/// <summary>Widens the upper half of a <see langword="Vector256&lt;SByte&gt;" /> into a <see cref="Vector256{Int16} " />.</summary> 4120public static Vector256<short> WidenUpper(Vector256<sbyte> source) 4130/// <summary>Widens the upper half of a <see langword="Vector256&lt;Single&gt;" /> into a <see cref="Vector256{Double} " />.</summary> 4135public static Vector256<double> WidenUpper(Vector256<float> source) 4145/// <summary>Widens the upper half of a <see langword="Vector256&lt;UInt16&gt;" /> into a <see cref="Vector256{UInt32} " />.</summary> 4151public static Vector256<uint> WidenUpper(Vector256<ushort> source) 4161/// <summary>Widens the upper half of a <see langword="Vector256&lt;UInt32&gt;" /> into a <see cref="Vector256{UInt64} " />.</summary> 4167public static Vector256<ulong> WidenUpper(Vector256<uint> source) 4177/// <summary>Creates a new <see cref="Vector256{T}" /> with the element at the specified index set to the specified value and the remaining elements set to the same value as that in the given vector.</summary> 4182/// <returns>A <see cref="Vector256{T}" /> with the value of the element at <paramref name="index" /> set to <paramref name="value" /> and the remaining elements set to the same value as that in <paramref name="vector" />.</returns> 4186public static Vector256<T> WithElement<T>(this Vector256<T> vector, int index, T value) 4188if ((uint)(index) >= (uint)(Vector256<T>.Count)) 4193Vector256<T> result = vector; 4198/// <summary>Creates a new <see cref="Vector256{T}" /> with the lower 128-bits set to the specified value and the upper 128-bits set to the same value as that in the given vector.</summary> 4202/// <returns>A new <see cref="Vector256{T}" /> with the lower 128-bits set to <paramref name="value" /> and the upper 128-bits set to the same value as that in <paramref name="vector" />.</returns> 4206public static Vector256<T> WithLower<T>(this Vector256<T> vector, Vector128<T> value) 4210Vector256<T> result = vector; 4215/// <summary>Creates a new <see cref="Vector256{T}" /> with the upper 128-bits set to the specified value and the lower 128-bits set to the same value as that in the given vector.</summary> 4219/// <returns>A new <see cref="Vector256{T}" /> with the upper 128-bits set to <paramref name="value" /> and the lower 128-bits set to the same value as that in <paramref name="vector" />.</returns> 4223public static Vector256<T> WithUpper<T>(this Vector256<T> vector, Vector128<T> value) 4227Vector256<T> result = vector; 4239public static Vector256<T> Xor<T>(Vector256<T> left, Vector256<T> right) => left ^ right; 4242internal static int CountMatches<T>(Vector256<T> vector) 4256internal static T GetElementUnsafe<T>(in this Vector256<T> vector, int index) 4258Debug.Assert((index >= 0) && (index < Vector256<T>.Count)); 4259ref T address = ref Unsafe.As<Vector256<T>, T>(ref Unsafe.AsRef(in vector)); 4264internal static int IndexOfFirstMatch<T>(Vector256<T> vector) 4286internal static int IndexOfLastMatch<T>(Vector256<T> vector) 4305internal static void SetElementUnsafe<T>(in this Vector256<T> vector, int index, T value) 4307Debug.Assert((index >= 0) && (index < Vector256<T>.Count)); 4308ref T address = ref Unsafe.As<Vector256<T>, T>(ref Unsafe.AsRef(in vector)); 4312internal static void SetLowerUnsafe<T>(in this Vector256<T> vector, Vector128<T> value) => Unsafe.AsRef(in vector._lower) = value; 4314internal static void SetUpperUnsafe<T>(in this Vector256<T> vector, Vector128<T> value) => Unsafe.AsRef(in vector._upper) = value;
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256DebugView_1.cs (14)
10private readonly Vector256<T> _value; 12public Vector256DebugView(Vector256<T> value) 21var items = new byte[Vector256<byte>.Count]; 31var items = new double[Vector256<double>.Count]; 41var items = new short[Vector256<short>.Count]; 51var items = new int[Vector256<int>.Count]; 61var items = new long[Vector256<long>.Count]; 71var items = new nint[Vector256<nint>.Count]; 81var items = new nuint[Vector256<nuint>.Count]; 91var items = new sbyte[Vector256<sbyte>.Count]; 101var items = new float[Vector256<float>.Count]; 111var items = new ushort[Vector256<ushort>.Count]; 121var items = new uint[Vector256<uint>.Count]; 131var items = new ulong[Vector256<ulong>.Count];
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector512_1.cs (2)
33internal readonly Vector256<T> _lower; 34internal readonly Vector256<T> _upper;
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector512.cs (176)
186/// <inheritdoc cref="Vector256.All{T}(Vector256{T}, T)" /> 191/// <inheritdoc cref="Vector256.AllWhereAllBitsSet{T}(Vector256{T})" /> 220/// <inheritdoc cref="Vector256.Any{T}(Vector256{T}, T)" /> 225/// <inheritdoc cref="Vector256.AnyWhereAllBitsSet{T}(Vector256{T})" /> 447/// <inheritdoc cref="Vector256.Clamp{T}(Vector256{T}, Vector256{T}, Vector256{T})" /> 455/// <inheritdoc cref="Vector256.ClampNative{T}(Vector256{T}, Vector256{T}, Vector256{T})" /> 637/// <inheritdoc cref="Vector256.CopySign{T}(Vector256{T}, Vector256{T})" /> 720/// <inheritdoc cref="Vector256.Asin(Vector256{double})" /> 737/// <inheritdoc cref="Vector256.Asin(Vector256{float})" /> 754/// <inheritdoc cref="Vector256.Cos(Vector256{double})" /> 771/// <inheritdoc cref="Vector256.Cos(Vector256{float})" /> 788/// <inheritdoc cref="Vector256.Count{T}(Vector256{T}, T)" /> 793/// <inheritdoc cref="Vector256.CountWhereAllBitsSet{T}(Vector256{T})" /> 820Vector256<T> vector = Vector256.Create(value); 934/// <returns>A new <see cref="Vector512{T}" /> with its elements set to the first <see cref="Vector256{T}.Count" /> elements from <paramref name="values" />.</returns> 1395public static Vector512<T> Create<T>(Vector256<T> value) => Create(value, value); 1397/// <summary>Creates a new <see cref="Vector512{T}" /> instance from two <see cref="Vector256{T}" /> instances.</summary> 1404public static Vector512<T> Create<T>(Vector256<T> lower, Vector256<T> upper) 1419public static Vector512<byte> Create(Vector256<byte> lower, Vector256<byte> upper) => Create<byte>(lower, upper); 1426public static Vector512<double> Create(Vector256<double> lower, Vector256<double> upper) => Create<double>(lower, upper); 1432public static Vector512<short> Create(Vector256<short> lower, Vector256<short> upper) => Create<short>(lower, upper); 1439public static Vector512<int> Create(Vector256<int> lower, Vector256<int> upper) => Create<int>(lower, upper); 1445public static Vector512<long> Create(Vector256<long> lower, Vector256<long> upper) => Create<long>(lower, upper); 1451public static Vector512<nint> Create(Vector256<nint> lower, Vector256<nint> upper) => Create<nint>(lower, upper); 1458public static Vector512<nuint> Create(Vector256<nuint> lower, Vector256<nuint> upper) => Create<nuint>(lower, upper); 1465public static Vector512<sbyte> Create(Vector256<sbyte> lower, Vector256<sbyte> upper) => Create<sbyte>(lower, upper); 1472public static Vector512<float> Create(Vector256<float> lower, Vector256<float> upper) => Create<float>(lower, upper); 1479public static Vector512<ushort> Create(Vector256<ushort> lower, Vector256<ushort> upper) => Create<ushort>(lower, upper); 1487public static Vector512<uint> Create(Vector256<uint> lower, Vector256<uint> upper) => Create<uint>(lower, upper); 1494public static Vector512<ulong> Create(Vector256<ulong> lower, Vector256<ulong> upper) => Create<ulong>(lower, upper); 1731Vector256<T> sequence = Vector256.CreateAlternatingSequence(even, odd); 1750T upperStart = Scalar<T>.Add(start, Scalar<T>.Multiply(Scalar<T>.Convert(Vector256<T>.Count), step)); 1818(Vector256<T> lower0, Vector256<T> upper0) = Vector256.Zip(left.GetLower(), right.GetLower()); 1819(Vector256<T> lower1, Vector256<T> upper1) = Vector256.Zip(left.GetUpper(), right.GetUpper()); 1867(Vector256<T> even0, Vector256<T> odd0) = Vector256.Unzip(left.GetLower(), left.GetUpper()); 1868(Vector256<T> even1, Vector256<T> odd1) = Vector256.Unzip(right.GetLower(), right.GetUpper()); 1881/// <inheritdoc cref="Vector256.DegreesToRadians(Vector256{double})" /> 1899/// <inheritdoc cref="Vector256.DegreesToRadians(Vector256{float})" /> 1984/// <inheritdoc cref="Vector256.Exp(Vector256{double})" /> 2001/// <inheritdoc cref="Vector256.Exp(Vector256{float})" /> 2029result |= (ulong)(vector._upper.ExtractMostSignificantBits()) << Vector256<T>.Count; 2068/// <inheritdoc cref="Vector256.FusedMultiplyAdd(Vector256{double}, Vector256{double}, Vector256{double})" /> 2079/// <inheritdoc cref="Vector256.FusedMultiplyAdd(Vector256{float}, Vector256{float}, Vector256{float})" /> 2109/// <summary>Gets the value of the lower 256-bits as a new <see cref="Vector256{T}" />.</summary> 2112/// <returns>The value of the lower 256-bits as a new <see cref="Vector256{T}" />.</returns> 2115public static Vector256<T> GetLower<T>(this Vector512<T> vector) 2121/// <summary>Gets the value of the upper 256-bits as a new <see cref="Vector256{T}" />.</summary> 2124/// <returns>The value of the upper 256-bits as a new <see cref="Vector256{T}" />.</returns> 2127public static Vector256<T> GetUpper<T>(this Vector512<T> vector) 2221/// <inheritdoc cref="Vector256.Hypot(Vector256{double}, Vector256{double})" /> 2238/// <inheritdoc cref="Vector256.Hypot(Vector256{float}, Vector256{float})" /> 2255/// <inheritdoc cref="Vector256.IndexOf{T}(Vector256{T}, T)" /> 2260/// <inheritdoc cref="Vector256.IndexOfWhereAllBitsSet{T}(Vector256{T})" /> 2279/// <inheritdoc cref="Vector256.IsEvenInteger{T}(Vector256{T})" /> 2295/// <inheritdoc cref="Vector256.IsFinite{T}(Vector256{T})" /> 2311/// <inheritdoc cref="Vector256.IsInfinity{T}(Vector256{T})" /> 2323/// <inheritdoc cref="Vector256.IsInteger{T}(Vector256{T})" /> 2335/// <inheritdoc cref="Vector256.IsNaN{T}(Vector256{T})" /> 2347/// <inheritdoc cref="Vector256.IsNegative{T}(Vector256{T})" /> 2370/// <inheritdoc cref="Vector256.IsNegativeInfinity{T}(Vector256{T})" /> 2386/// <inheritdoc cref="Vector256.IsNormal{T}(Vector256{T})" /> 2402/// <inheritdoc cref="Vector256.IsOddInteger{T}(Vector256{T})" /> 2418/// <inheritdoc cref="Vector256.IsPositive{T}(Vector256{T})" /> 2441/// <inheritdoc cref="Vector256.IsPositiveInfinity{T}(Vector256{T})" /> 2457/// <inheritdoc cref="Vector256.IsSubnormal{T}(Vector256{T})" /> 2473/// <inheritdoc cref="Vector256.IsZero{T}(Vector256{T})" /> 2478/// <inheritdoc cref="Vector256.LastIndexOf{T}(Vector256{T}, T)" /> 2483/// <inheritdoc cref="Vector256.LastIndexOfWhereAllBitsSet{T}(Vector256{T})" /> 2502/// <inheritdoc cref="Vector256.Lerp(Vector256{double}, Vector256{double}, Vector256{double})" /> 2520/// <inheritdoc cref="Vector256.Lerp(Vector256{float}, Vector256{float}, Vector256{float})" /> 2706/// <inheritdoc cref="Vector256.Log(Vector256{double})" /> 2723/// <inheritdoc cref="Vector256.Log(Vector256{float})" /> 2740/// <inheritdoc cref="Vector256.Log2(Vector256{double})" /> 2757/// <inheritdoc cref="Vector256.Log2(Vector256{float})" /> 2774/// <inheritdoc cref="Vector256.Max{T}(Vector256{T}, Vector256{T})" /> 2792/// <inheritdoc cref="Vector256.MaxMagnitude{T}(Vector256{T}, Vector256{T})" /> 2810/// <inheritdoc cref="Vector256.MaxMagnitudeNumber{T}(Vector256{T}, Vector256{T})" /> 2828/// <inheritdoc cref="Vector256.MaxNative{T}(Vector256{T}, Vector256{T})" /> 2846/// <inheritdoc cref="Vector256.MaxNumber{T}(Vector256{T}, Vector256{T})" /> 2864/// <inheritdoc cref="Vector256.Min{T}(Vector256{T}, Vector256{T})" /> 2882/// <inheritdoc cref="Vector256.MinMagnitude{T}(Vector256{T}, Vector256{T})" /> 2900/// <inheritdoc cref="Vector256.MinMagnitudeNumber{T}(Vector256{T}, Vector256{T})" /> 2918/// <inheritdoc cref="Vector256.MinNative{T}(Vector256{T}, Vector256{T})" /> 2936/// <inheritdoc cref="Vector256.MinNumber{T}(Vector256{T}, Vector256{T})" /> 2991/// <inheritdoc cref="Vector256.MultiplyAddEstimate(Vector256{double}, Vector256{double}, Vector256{double})" /> 3002/// <inheritdoc cref="Vector256.MultiplyAddEstimate(Vector256{float}, Vector256{float}, Vector256{float})" /> 3158/// <inheritdoc cref="Vector256.None{T}(Vector256{T}, T)" /> 3163/// <inheritdoc cref="Vector256.NoneWhereAllBitsSet{T}(Vector256{T})" /> 3190/// <inheritdoc cref="Vector256.RadiansToDegrees(Vector256{double})" /> 3208/// <inheritdoc cref="Vector256.RadiansToDegrees(Vector256{float})" /> 3244/// <inheritdoc cref="Vector256.Round(Vector256{double})" /> 3248/// <inheritdoc cref="Vector256.Round(Vector256{float})" /> 3252/// <inheritdoc cref="Vector256.Round(Vector256{double}, MidpointRounding)" /> 3256/// <inheritdoc cref="Vector256.Round(Vector256{float}, MidpointRounding)" /> 3640/// <inheritdoc cref="Vector256.Sin(Vector256{double})" /> 3657/// <inheritdoc cref="Vector256.Sin(Vector256{float})" /> 3674/// <inheritdoc cref="Vector256.SinCos(Vector256{double})" /> 3684(Vector256<double> sinLower, Vector256<double> cosLower) = Vector256.SinCos(vector._lower); 3685(Vector256<double> sinUpper, Vector256<double> cosUpper) = Vector256.SinCos(vector._upper); 3694/// <inheritdoc cref="Vector256.SinCos(Vector256{float})" /> 3704(Vector256<float> sinLower, Vector256<float> cosLower) = Vector256.SinCos(vector._lower); 3705(Vector256<float> sinUpper, Vector256<float> cosUpper) = Vector256.SinCos(vector._upper); 3868/// <inheritdoc cref="Vector256.Truncate(Vector256{double})" /> 3872/// <inheritdoc cref="Vector256.Truncate(Vector256{float})" /> 3947Vector256<byte> lower = source._lower; 3962Vector256<short> lower = source._lower; 3977Vector256<int> lower = source._lower; 3993Vector256<sbyte> lower = source._lower; 4007Vector256<float> lower = source._lower; 4023Vector256<ushort> lower = source._lower; 4039Vector256<uint> lower = source._lower; 4055Vector256<byte> upper = source._upper; 4070Vector256<short> upper = source._upper; 4085Vector256<int> upper = source._upper; 4101Vector256<sbyte> upper = source._upper; 4116Vector256<float> upper = source._upper; 4132Vector256<ushort> upper = source._upper; 4148Vector256<uint> upper = source._upper; 4180/// <param name="value">The value of the lower 256-bits as a <see cref="Vector256{T}" />.</param> 4185public static Vector512<T> WithLower<T>(this Vector512<T> vector, Vector256<T> value) 4197/// <param name="value">The value of the upper 256-bits as a <see cref="Vector256{T}" />.</param> 4202public static Vector512<T> WithUpper<T>(this Vector512<T> vector, Vector256<T> value) 4260return result + ((result >= 0) ? Vector256<T>.Count : 0); 4277return result + Vector256<T>.Count; 4291internal static void SetLowerUnsafe<T>(in this Vector512<T> vector, Vector256<T> value) => Unsafe.AsRef(in vector._lower) = value; 4293internal static void SetUpperUnsafe<T>(in this Vector512<T> vector, Vector256<T> value) => Unsafe.AsRef(in vector._upper) = value;
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\VectorMath.cs (38)
2536else if (typeof(TVectorInt64) == typeof(Vector256<long>)) 2538result = (TVectorDouble)(object)Vector256.ConvertToDouble((Vector256<long>)(object)vector); 2571else if (typeof(TVectorInt32) == typeof(Vector256<int>)) 2573result = (TVectorSingle)(object)Vector256.ConvertToSingle((Vector256<int>)(object)vector); 2695else if (typeof(TVectorDouble) == typeof(Vector256<double>)) 2697result = (TVectorDouble)(object)Vector256.FusedMultiplyAdd((Vector256<double>)(object)left, (Vector256<double>)(object)right, (Vector256<double>)(object)addend); 2729else if (typeof(TVector) == typeof(Vector256<double>)) 2763else if (typeof(TVector) == typeof(Vector256<float>)) 2804else if (typeof(TVectorDouble) == typeof(Vector256<double>)) 2810result = (TVectorSingle)(object)Avx.ConvertToVector128Single((Vector256<double>)(object)vector); 2814Vector256<double> value = (Vector256<double>)(object)vector; 2820Debug.Assert(typeof(TVectorSingle) == typeof(Vector256<float>)); 2862else if (typeof(TVectorDouble) == typeof(Vector256<double>)) 2864Debug.Assert(typeof(TVectorSingle) == typeof(Vector256<float>)); 2865result = (TVectorSingle)(object)Vector256.Narrow((Vector256<double>)(object)lower, (Vector256<double>)(object)upper); 2907else if (typeof(TVectorUInt32) == typeof(Vector256<uint>)) 2910(Vector256<uint>)(object)vector, 2911(Vector256<uint>)(object)shiftAmount 2956else if (typeof(TVectorUInt64) == typeof(Vector256<ulong>)) 2959(Vector256<ulong>)(object)vector, 2960(Vector256<ulong>)(object)shiftAmount 3128Debug.Assert(typeof(TVectorDouble) == typeof(Vector256<double>)); 3144else if (typeof(TVectorSingle) == typeof(Vector256<float>)) 3150result = (TVectorDouble)(object)Avx512F.ConvertToVector512Double((Vector256<float>)(object)vector); 3154Vector256<float> value = (Vector256<float>)(object)vector; 3156Vector256<double> lower = Vector256.WidenLower(value); 3157Vector256<double> upper = Vector256.WidenUpper(value); 3192else if (typeof(TVectorSingle) == typeof(Vector256<float>)) 3194Debug.Assert(typeof(TVectorDouble) == typeof(Vector256<double>)); 3195result = (TVectorDouble)(object)Vector256.WidenLower((Vector256<float>)(object)vector); 3232else if (typeof(TVectorSingle) == typeof(Vector256<float>)) 3234Debug.Assert(typeof(TVectorDouble) == typeof(Vector256<double>)); 3235result = (TVectorDouble)(object)Vector256.WidenUpper((Vector256<float>)(object)vector);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Avx.cs (446)
39public static Vector256<float> Add(Vector256<float> left, Vector256<float> right) => Add(left, right); 45public static Vector256<double> Add(Vector256<double> left, Vector256<double> right) => Add(left, right); 51public static Vector256<float> AddSubtract(Vector256<float> left, Vector256<float> right) => AddSubtract(left, right); 56public static Vector256<double> AddSubtract(Vector256<double> left, Vector256<double> right) => AddSubtract(left, right); 63public static Vector256<float> And(Vector256<float> left, Vector256<float> right) => And(left, right); 69public static Vector256<double> And(Vector256<double> left, Vector256<double> right) => And(left, right); 76public static Vector256<float> AndNot(Vector256<float> left, Vector256<float> right) => AndNot(left, right); 82public static Vector256<double> AndNot(Vector256<double> left, Vector256<double> right) => AndNot(left, right); 88public static Vector256<float> Blend(Vector256<float> left, Vector256<float> right, [ConstantExpected] byte control) => Blend(left, right, control); 93public static Vector256<double> Blend(Vector256<double> left, Vector256<double> right, [ConstantExpected] byte control) => Blend(left, right, control); 99public static Vector256<float> BlendVariable(Vector256<float> left, Vector256<float> right, Vector256<float> mask) => BlendVariable(left, right, mask); 104public static Vector256<double> BlendVariable(Vector256<double> left, Vector256<double> right, Vector256<double> mask) => BlendVariable(left, right, mask); 118public static unsafe Vector256<float> BroadcastScalarToVector256(float* source) => BroadcastScalarToVector256(source); 125public static unsafe Vector256<double> BroadcastScalarToVector256(double* source) => BroadcastScalarToVector256(source); 132public static unsafe Vector256<float> BroadcastVector128ToVector256(float* address) => BroadcastVector128ToVector256(address); 139public static unsafe Vector256<double> BroadcastVector128ToVector256(double* address) => BroadcastVector128ToVector256(address); 145public static Vector256<float> Ceiling(Vector256<float> value) => Ceiling(value); 150public static Vector256<double> Ceiling(Vector256<double> value) => Ceiling(value); 161public static Vector256<float> Compare(Vector256<float> left, Vector256<float> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode); 167public static Vector256<float> CompareEqual(Vector256<float> left, Vector256<float> right) => CompareEqual(left, right); 173public static Vector256<float> CompareGreaterThan(Vector256<float> left, Vector256<float> right) => CompareGreaterThan(left, right); 179public static Vector256<float> CompareGreaterThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareGreaterThanOrEqual(left, right); 185public static Vector256<float> CompareLessThan(Vector256<float> left, Vector256<float> right) => CompareLessThan(left, right); 191public static Vector256<float> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareLessThanOrEqual(left, right); 197public static Vector256<float> CompareNotEqual(Vector256<float> left, Vector256<float> right) => CompareNotEqual(left, right); 203public static Vector256<float> CompareNotGreaterThan(Vector256<float> left, Vector256<float> right) => CompareNotGreaterThan(left, right); 209public static Vector256<float> CompareNotGreaterThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareNotGreaterThanOrEqual(left, right); 215public static Vector256<float> CompareNotLessThan(Vector256<float> left, Vector256<float> right) => CompareNotLessThan(left, right); 221public static Vector256<float> CompareNotLessThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareNotLessThanOrEqual(left, right); 227public static Vector256<float> CompareOrdered(Vector256<float> left, Vector256<float> right) => CompareOrdered(left, right); 233public static Vector256<float> CompareUnordered(Vector256<float> left, Vector256<float> right) => CompareUnordered(left, right); 244public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode); 250public static Vector256<double> CompareEqual(Vector256<double> left, Vector256<double> right) => CompareEqual(left, right); 256public static Vector256<double> CompareGreaterThan(Vector256<double> left, Vector256<double> right) => CompareGreaterThan(left, right); 262public static Vector256<double> CompareGreaterThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareGreaterThanOrEqual(left, right); 268public static Vector256<double> CompareLessThan(Vector256<double> left, Vector256<double> right) => CompareLessThan(left, right); 274public static Vector256<double> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareLessThanOrEqual(left, right); 280public static Vector256<double> CompareNotEqual(Vector256<double> left, Vector256<double> right) => CompareNotEqual(left, right); 286public static Vector256<double> CompareNotGreaterThan(Vector256<double> left, Vector256<double> right) => CompareNotGreaterThan(left, right); 292public static Vector256<double> CompareNotGreaterThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareNotGreaterThanOrEqual(left, right); 298public static Vector256<double> CompareNotLessThan(Vector256<double> left, Vector256<double> right) => CompareNotLessThan(left, right); 304public static Vector256<double> CompareNotLessThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareNotLessThanOrEqual(left, right); 310public static Vector256<double> CompareOrdered(Vector256<double> left, Vector256<double> right) => CompareOrdered(left, right); 316public static Vector256<double> CompareUnordered(Vector256<double> left, Vector256<double> right) => CompareUnordered(left, right); 334public static Vector128<int> ConvertToVector128Int32(Vector256<double> value) => ConvertToVector128Int32(value); 341public static Vector128<float> ConvertToVector128Single(Vector256<double> value) => ConvertToVector128Single(value); 348public static Vector256<double> ConvertToVector256Double(Vector128<int> value) => ConvertToVector256Double(value); 354public static Vector256<double> ConvertToVector256Double(Vector128<float> value) => ConvertToVector256Double(value); 360public static Vector256<int> ConvertToVector256Int32(Vector256<float> value) => ConvertToVector256Int32(value); 366public static Vector256<float> ConvertToVector256Single(Vector256<int> value) => ConvertToVector256Single(value); 373public static Vector256<int> ConvertToVector256Int32WithTruncation(Vector256<float> value) => ConvertToVector256Int32WithTruncation(value); 379public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector256<double> value) => ConvertToVector128Int32WithTruncation(value); 386public static Vector256<float> Divide(Vector256<float> left, Vector256<float> right) => Divide(left, right); 392public static Vector256<double> Divide(Vector256<double> left, Vector256<double> right) => Divide(left, right); 398public static Vector256<float> DotProduct(Vector256<float> left, Vector256<float> right, [ConstantExpected] byte control) => DotProduct(left, right, control); 405public static Vector256<float> DuplicateEvenIndexed(Vector256<float> value) => DuplicateEvenIndexed(value); 411public static Vector256<double> DuplicateEvenIndexed(Vector256<double> value) => DuplicateEvenIndexed(value); 417public static Vector256<float> DuplicateOddIndexed(Vector256<float> value) => DuplicateOddIndexed(value); 424public static Vector128<byte> ExtractVector128(Vector256<byte> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 430public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 436public static Vector128<short> ExtractVector128(Vector256<short> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 442public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 448public static Vector128<int> ExtractVector128(Vector256<int> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 454public static Vector128<uint> ExtractVector128(Vector256<uint> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 460public static Vector128<long> ExtractVector128(Vector256<long> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 466public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 472public static Vector128<float> ExtractVector128(Vector256<float> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 478public static Vector128<double> ExtractVector128(Vector256<double> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 484public static Vector256<float> Floor(Vector256<float> value) => Floor(value); 489public static Vector256<double> Floor(Vector256<double> value) => Floor(value); 495public static Vector256<float> HorizontalAdd(Vector256<float> left, Vector256<float> right) => HorizontalAdd(left, right); 500public static Vector256<double> HorizontalAdd(Vector256<double> left, Vector256<double> right) => HorizontalAdd(left, right); 506public static Vector256<float> HorizontalSubtract(Vector256<float> left, Vector256<float> right) => HorizontalSubtract(left, right); 511public static Vector256<double> HorizontalSubtract(Vector256<double> left, Vector256<double> right) => HorizontalSubtract(left, right); 518public static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 524public static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 530public static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 536public static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 542public static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 548public static Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 554public static Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 560public static Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 566public static Vector256<float> InsertVector128(Vector256<float> value, Vector128<float> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 572public static Vector256<double> InsertVector128(Vector256<double> value, Vector128<double> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 579public static unsafe Vector256<sbyte> LoadAlignedVector256(sbyte* address) => LoadAlignedVector256(address); 586public static unsafe Vector256<byte> LoadAlignedVector256(byte* address) => LoadAlignedVector256(address); 593public static unsafe Vector256<short> LoadAlignedVector256(short* address) => LoadAlignedVector256(address); 600public static unsafe Vector256<ushort> LoadAlignedVector256(ushort* address) => LoadAlignedVector256(address); 607public static unsafe Vector256<int> LoadAlignedVector256(int* address) => LoadAlignedVector256(address); 614public static unsafe Vector256<uint> LoadAlignedVector256(uint* address) => LoadAlignedVector256(address); 621public static unsafe Vector256<long> LoadAlignedVector256(long* address) => LoadAlignedVector256(address); 628public static unsafe Vector256<ulong> LoadAlignedVector256(ulong* address) => LoadAlignedVector256(address); 635public static unsafe Vector256<float> LoadAlignedVector256(float* address) => LoadAlignedVector256(address); 642public static unsafe Vector256<double> LoadAlignedVector256(double* address) => LoadAlignedVector256(address); 648public static unsafe Vector256<sbyte> LoadDquVector256(sbyte* address) => LoadDquVector256(address); 654public static unsafe Vector256<byte> LoadDquVector256(byte* address) => LoadDquVector256(address); 660public static unsafe Vector256<short> LoadDquVector256(short* address) => LoadDquVector256(address); 666public static unsafe Vector256<ushort> LoadDquVector256(ushort* address) => LoadDquVector256(address); 672public static unsafe Vector256<int> LoadDquVector256(int* address) => LoadDquVector256(address); 678public static unsafe Vector256<uint> LoadDquVector256(uint* address) => LoadDquVector256(address); 684public static unsafe Vector256<long> LoadDquVector256(long* address) => LoadDquVector256(address); 690public static unsafe Vector256<ulong> LoadDquVector256(ulong* address) => LoadDquVector256(address); 697public static unsafe Vector256<sbyte> LoadVector256(sbyte* address) => LoadVector256(address); 704public static unsafe Vector256<byte> LoadVector256(byte* address) => LoadVector256(address); 711public static unsafe Vector256<short> LoadVector256(short* address) => LoadVector256(address); 718public static unsafe Vector256<ushort> LoadVector256(ushort* address) => LoadVector256(address); 725public static unsafe Vector256<int> LoadVector256(int* address) => LoadVector256(address); 732public static unsafe Vector256<uint> LoadVector256(uint* address) => LoadVector256(address); 739public static unsafe Vector256<long> LoadVector256(long* address) => LoadVector256(address); 746public static unsafe Vector256<ulong> LoadVector256(ulong* address) => LoadVector256(address); 753public static unsafe Vector256<float> LoadVector256(float* address) => LoadVector256(address); 760public static unsafe Vector256<double> LoadVector256(double* address) => LoadVector256(address); 778public static unsafe Vector256<float> MaskLoad(float* address, Vector256<float> mask) => MaskLoad(address, mask); 784public static unsafe Vector256<double> MaskLoad(double* address, Vector256<double> mask) => MaskLoad(address, mask); 802public static unsafe void MaskStore(float* address, Vector256<float> mask, Vector256<float> source) => MaskStore(address, mask, source); 808public static unsafe void MaskStore(double* address, Vector256<double> mask, Vector256<double> source) => MaskStore(address, mask, source); 815public static Vector256<float> Max(Vector256<float> left, Vector256<float> right) => Max(left, right); 821public static Vector256<double> Max(Vector256<double> left, Vector256<double> right) => Max(left, right); 828public static Vector256<float> Min(Vector256<float> left, Vector256<float> right) => Min(left, right); 834public static Vector256<double> Min(Vector256<double> left, Vector256<double> right) => Min(left, right); 840public static int MoveMask(Vector256<float> value) => MoveMask(value); 845public static int MoveMask(Vector256<double> value) => MoveMask(value); 852public static Vector256<float> Multiply(Vector256<float> left, Vector256<float> right) => Multiply(left, right); 858public static Vector256<double> Multiply(Vector256<double> left, Vector256<double> right) => Multiply(left, right); 865public static Vector256<float> Or(Vector256<float> left, Vector256<float> right) => Or(left, right); 871public static Vector256<double> Or(Vector256<double> left, Vector256<double> right) => Or(left, right); 890public static Vector256<float> Permute(Vector256<float> value, [ConstantExpected] byte control) => Permute(value, control); 896public static Vector256<double> Permute(Vector256<double> value, [ConstantExpected] byte control) => Permute(value, control); 902public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 907public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 912public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 917public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 922public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 927public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 932public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 937public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 942public static Vector256<float> Permute2x128(Vector256<float> left, Vector256<float> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 947public static Vector256<double> Permute2x128(Vector256<double> left, Vector256<double> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 966public static Vector256<float> PermuteVar(Vector256<float> left, Vector256<int> control) => PermuteVar(left, control); 972public static Vector256<double> PermuteVar(Vector256<double> left, Vector256<long> control) => PermuteVar(left, control); 978public static Vector256<float> Reciprocal(Vector256<float> value) => Reciprocal(value); 984public static Vector256<float> ReciprocalSqrt(Vector256<float> value) => ReciprocalSqrt(value); 991public static Vector256<float> RoundCurrentDirection(Vector256<float> value) => RoundCurrentDirection(value); 997public static Vector256<double> RoundCurrentDirection(Vector256<double> value) => RoundCurrentDirection(value); 1004public static Vector256<float> RoundToNearestInteger(Vector256<float> value) => RoundToNearestInteger(value); 1010public static Vector256<double> RoundToNearestInteger(Vector256<double> value) => RoundToNearestInteger(value); 1017public static Vector256<float> RoundToNegativeInfinity(Vector256<float> value) => RoundToNegativeInfinity(value); 1023public static Vector256<double> RoundToNegativeInfinity(Vector256<double> value) => RoundToNegativeInfinity(value); 1030public static Vector256<float> RoundToPositiveInfinity(Vector256<float> value) => RoundToPositiveInfinity(value); 1036public static Vector256<double> RoundToPositiveInfinity(Vector256<double> value) => RoundToPositiveInfinity(value); 1043public static Vector256<float> RoundToZero(Vector256<float> value) => RoundToZero(value); 1049public static Vector256<double> RoundToZero(Vector256<double> value) => RoundToZero(value); 1056public static Vector256<float> Shuffle(Vector256<float> value, Vector256<float> right, [ConstantExpected] byte control) => Shuffle(value, right, control); 1062public static Vector256<double> Shuffle(Vector256<double> value, Vector256<double> right, [ConstantExpected] byte control) => Shuffle(value, right, control); 1069public static Vector256<float> Sqrt(Vector256<float> value) => Sqrt(value); 1075public static Vector256<double> Sqrt(Vector256<double> value) => Sqrt(value); 1082public static unsafe void Store(sbyte* address, Vector256<sbyte> source) => Store(address, source); 1089public static unsafe void Store(byte* address, Vector256<byte> source) => Store(address, source); 1096public static unsafe void Store(short* address, Vector256<short> source) => Store(address, source); 1103public static unsafe void Store(ushort* address, Vector256<ushort> source) => Store(address, source); 1110public static unsafe void Store(int* address, Vector256<int> source) => Store(address, source); 1117public static unsafe void Store(uint* address, Vector256<uint> source) => Store(address, source); 1124public static unsafe void Store(long* address, Vector256<long> source) => Store(address, source); 1131public static unsafe void Store(ulong* address, Vector256<ulong> source) => Store(address, source); 1138public static unsafe void Store(float* address, Vector256<float> source) => Store(address, source); 1145public static unsafe void Store(double* address, Vector256<double> source) => Store(address, source); 1152public static unsafe void StoreAligned(sbyte* address, Vector256<sbyte> source) => StoreAligned(address, source); 1159public static unsafe void StoreAligned(byte* address, Vector256<byte> source) => StoreAligned(address, source); 1166public static unsafe void StoreAligned(short* address, Vector256<short> source) => StoreAligned(address, source); 1173public static unsafe void StoreAligned(ushort* address, Vector256<ushort> source) => StoreAligned(address, source); 1180public static unsafe void StoreAligned(int* address, Vector256<int> source) => StoreAligned(address, source); 1187public static unsafe void StoreAligned(uint* address, Vector256<uint> source) => StoreAligned(address, source); 1194public static unsafe void StoreAligned(long* address, Vector256<long> source) => StoreAligned(address, source); 1201public static unsafe void StoreAligned(ulong* address, Vector256<ulong> source) => StoreAligned(address, source); 1208public static unsafe void StoreAligned(float* address, Vector256<float> source) => StoreAligned(address, source); 1215public static unsafe void StoreAligned(double* address, Vector256<double> source) => StoreAligned(address, source); 1221public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector256<sbyte> source) => StoreAlignedNonTemporal(address, source); 1227public static unsafe void StoreAlignedNonTemporal(byte* address, Vector256<byte> source) => StoreAlignedNonTemporal(address, source); 1233public static unsafe void StoreAlignedNonTemporal(short* address, Vector256<short> source) => StoreAlignedNonTemporal(address, source); 1239public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector256<ushort> source) => StoreAlignedNonTemporal(address, source); 1245public static unsafe void StoreAlignedNonTemporal(int* address, Vector256<int> source) => StoreAlignedNonTemporal(address, source); 1251public static unsafe void StoreAlignedNonTemporal(uint* address, Vector256<uint> source) => StoreAlignedNonTemporal(address, source); 1257public static unsafe void StoreAlignedNonTemporal(long* address, Vector256<long> source) => StoreAlignedNonTemporal(address, source); 1263public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector256<ulong> source) => StoreAlignedNonTemporal(address, source); 1269public static unsafe void StoreAlignedNonTemporal(float* address, Vector256<float> source) => StoreAlignedNonTemporal(address, source); 1275public static unsafe void StoreAlignedNonTemporal(double* address, Vector256<double> source) => StoreAlignedNonTemporal(address, source); 1282public static Vector256<float> Subtract(Vector256<float> left, Vector256<float> right) => Subtract(left, right); 1288public static Vector256<double> Subtract(Vector256<double> left, Vector256<double> right) => Subtract(left, right); 1304public static bool TestC(Vector256<byte> left, Vector256<byte> right) => TestC(left, right); 1309public static bool TestC(Vector256<sbyte> left, Vector256<sbyte> right) => TestC(left, right); 1314public static bool TestC(Vector256<short> left, Vector256<short> right) => TestC(left, right); 1319public static bool TestC(Vector256<ushort> left, Vector256<ushort> right) => TestC(left, right); 1324public static bool TestC(Vector256<int> left, Vector256<int> right) => TestC(left, right); 1329public static bool TestC(Vector256<uint> left, Vector256<uint> right) => TestC(left, right); 1334public static bool TestC(Vector256<long> left, Vector256<long> right) => TestC(left, right); 1339public static bool TestC(Vector256<ulong> left, Vector256<ulong> right) => TestC(left, right); 1344public static bool TestC(Vector256<float> left, Vector256<float> right) => TestC(left, right); 1349public static bool TestC(Vector256<double> left, Vector256<double> right) => TestC(left, right); 1365public static bool TestNotZAndNotC(Vector256<byte> left, Vector256<byte> right) => TestNotZAndNotC(left, right); 1370public static bool TestNotZAndNotC(Vector256<sbyte> left, Vector256<sbyte> right) => TestNotZAndNotC(left, right); 1375public static bool TestNotZAndNotC(Vector256<short> left, Vector256<short> right) => TestNotZAndNotC(left, right); 1380public static bool TestNotZAndNotC(Vector256<ushort> left, Vector256<ushort> right) => TestNotZAndNotC(left, right); 1385public static bool TestNotZAndNotC(Vector256<int> left, Vector256<int> right) => TestNotZAndNotC(left, right); 1390public static bool TestNotZAndNotC(Vector256<uint> left, Vector256<uint> right) => TestNotZAndNotC(left, right); 1395public static bool TestNotZAndNotC(Vector256<long> left, Vector256<long> right) => TestNotZAndNotC(left, right); 1400public static bool TestNotZAndNotC(Vector256<ulong> left, Vector256<ulong> right) => TestNotZAndNotC(left, right); 1405public static bool TestNotZAndNotC(Vector256<float> left, Vector256<float> right) => TestNotZAndNotC(left, right); 1410public static bool TestNotZAndNotC(Vector256<double> left, Vector256<double> right) => TestNotZAndNotC(left, right); 1426public static bool TestZ(Vector256<byte> left, Vector256<byte> right) => TestZ(left, right); 1431public static bool TestZ(Vector256<sbyte> left, Vector256<sbyte> right) => TestZ(left, right); 1436public static bool TestZ(Vector256<short> left, Vector256<short> right) => TestZ(left, right); 1441public static bool TestZ(Vector256<ushort> left, Vector256<ushort> right) => TestZ(left, right); 1446public static bool TestZ(Vector256<int> left, Vector256<int> right) => TestZ(left, right); 1451public static bool TestZ(Vector256<uint> left, Vector256<uint> right) => TestZ(left, right); 1456public static bool TestZ(Vector256<long> left, Vector256<long> right) => TestZ(left, right); 1461public static bool TestZ(Vector256<ulong> left, Vector256<ulong> right) => TestZ(left, right); 1466public static bool TestZ(Vector256<float> left, Vector256<float> right) => TestZ(left, right); 1471public static bool TestZ(Vector256<double> left, Vector256<double> right) => TestZ(left, right); 1478public static Vector256<float> UnpackHigh(Vector256<float> left, Vector256<float> right) => UnpackHigh(left, right); 1484public static Vector256<double> UnpackHigh(Vector256<double> left, Vector256<double> right) => UnpackHigh(left, right); 1491public static Vector256<float> UnpackLow(Vector256<float> left, Vector256<float> right) => UnpackLow(left, right); 1497public static Vector256<double> UnpackLow(Vector256<double> left, Vector256<double> right) => UnpackLow(left, right); 1504public static Vector256<float> Xor(Vector256<float> left, Vector256<float> right) => Xor(left, right); 1510public static Vector256<double> Xor(Vector256<double> left, Vector256<double> right) => Xor(left, right);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Avx10v1.cs (850)
31public static Vector256<ulong> Abs(Vector256<long> value) => Abs(value); 59public static Vector256<int> AlignRight32(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); 64public static Vector256<uint> AlignRight32(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); 80public static Vector256<long> AlignRight64(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); 85public static Vector256<ulong> AlignRight64(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); 153public static new Vector256<byte> BlendVariable(Vector256<byte> left, Vector256<byte> right, Vector256<byte> mask) => BlendVariable(left, right, mask); 159public static new Vector256<double> BlendVariable(Vector256<double> left, Vector256<double> right, Vector256<double> mask) => BlendVariable(left, right, mask); 165public static new Vector256<short> BlendVariable(Vector256<short> left, Vector256<short> right, Vector256<short> mask) => BlendVariable(left, right, mask); 171public static new Vector256<int> BlendVariable(Vector256<int> left, Vector256<int> right, Vector256<int> mask) => BlendVariable(left, right, mask); 177public static new Vector256<long> BlendVariable(Vector256<long> left, Vector256<long> right, Vector256<long> mask) => BlendVariable(left, right, mask); 183public static new Vector256<sbyte> BlendVariable(Vector256<sbyte> left, Vector256<sbyte> right, Vector256<sbyte> mask) => BlendVariable(left, right, mask); 189public static new Vector256<float> BlendVariable(Vector256<float> left, Vector256<float> right, Vector256<float> mask) => BlendVariable(left, right, mask); 195public static new Vector256<ushort> BlendVariable(Vector256<ushort> left, Vector256<ushort> right, Vector256<ushort> mask) => BlendVariable(left, right, mask); 201public static new Vector256<uint> BlendVariable(Vector256<uint> left, Vector256<uint> right, Vector256<uint> mask) => BlendVariable(left, right, mask); 207public static new Vector256<ulong> BlendVariable(Vector256<ulong> left, Vector256<ulong> right, Vector256<ulong> mask) => BlendVariable(left, right, mask); 224public static Vector256<float> BroadcastPairScalarToVector256(Vector128<float> value) => BroadcastPairScalarToVector256(value); 229public static Vector256<int> BroadcastPairScalarToVector256(Vector128<int> value) => BroadcastPairScalarToVector256(value); 234public static Vector256<uint> BroadcastPairScalarToVector256(Vector128<uint> value) => BroadcastPairScalarToVector256(value); 250public static Vector256<double> Classify(Vector256<double> value, [ConstantExpected] byte control) => Classify(value, control); 255public static Vector256<float> Classify(Vector256<float> value, [ConstantExpected] byte control) => Classify(value, control); 303public static new Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right) => CompareEqual(left, right); 308public static Vector256<byte> CompareGreaterThan(Vector256<byte> left, Vector256<byte> right) => CompareGreaterThan(left, right); 313public static Vector256<byte> CompareGreaterThanOrEqual(Vector256<byte> left, Vector256<byte> right) => CompareGreaterThanOrEqual(left, right); 318public static Vector256<byte> CompareLessThan(Vector256<byte> left, Vector256<byte> right) => CompareLessThan(left, right); 323public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> left, Vector256<byte> right) => CompareLessThanOrEqual(left, right); 328public static Vector256<byte> CompareNotEqual(Vector256<byte> left, Vector256<byte> right) => CompareNotEqual(left, right); 412public static new Vector256<double> Compare(Vector256<double> left, Vector256<double> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode); 418public static new Vector256<double> CompareEqual(Vector256<double> left, Vector256<double> right) => CompareEqual(left, right); 424public static new Vector256<double> CompareGreaterThan(Vector256<double> left, Vector256<double> right) => CompareGreaterThan(left, right); 430public static new Vector256<double> CompareGreaterThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareGreaterThanOrEqual(left, right); 436public static new Vector256<double> CompareLessThan(Vector256<double> left, Vector256<double> right) => CompareLessThan(left, right); 442public static new Vector256<double> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareLessThanOrEqual(left, right); 448public static new Vector256<double> CompareNotEqual(Vector256<double> left, Vector256<double> right) => CompareNotEqual(left, right); 454public static new Vector256<double> CompareNotGreaterThan(Vector256<double> left, Vector256<double> right) => CompareNotGreaterThan(left, right); 460public static new Vector256<double> CompareNotGreaterThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareNotGreaterThanOrEqual(left, right); 466public static new Vector256<double> CompareNotLessThan(Vector256<double> left, Vector256<double> right) => CompareNotLessThan(left, right); 472public static new Vector256<double> CompareNotLessThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareNotLessThanOrEqual(left, right); 478public static new Vector256<double> CompareOrdered(Vector256<double> left, Vector256<double> right) => CompareOrdered(left, right); 484public static new Vector256<double> CompareUnordered(Vector256<double> left, Vector256<double> right) => CompareUnordered(left, right); 521public static new Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right) => CompareEqual(left, right); 526public static new Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right) => CompareGreaterThan(left, right); 531public static Vector256<short> CompareGreaterThanOrEqual(Vector256<short> left, Vector256<short> right) => CompareGreaterThanOrEqual(left, right); 536public static Vector256<short> CompareLessThan(Vector256<short> left, Vector256<short> right) => CompareLessThan(left, right); 541public static Vector256<short> CompareLessThanOrEqual(Vector256<short> left, Vector256<short> right) => CompareLessThanOrEqual(left, right); 546public static Vector256<short> CompareNotEqual(Vector256<short> left, Vector256<short> right) => CompareNotEqual(left, right); 583public static new Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right) => CompareEqual(left, right); 588public static new Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right) => CompareGreaterThan(left, right); 593public static Vector256<int> CompareGreaterThanOrEqual(Vector256<int> left, Vector256<int> right) => CompareGreaterThanOrEqual(left, right); 598public static Vector256<int> CompareLessThan(Vector256<int> left, Vector256<int> right) => CompareLessThan(left, right); 603public static Vector256<int> CompareLessThanOrEqual(Vector256<int> left, Vector256<int> right) => CompareLessThanOrEqual(left, right); 608public static Vector256<int> CompareNotEqual(Vector256<int> left, Vector256<int> right) => CompareNotEqual(left, right); 645public static new Vector256<long> CompareEqual(Vector256<long> left, Vector256<long> right) => CompareEqual(left, right); 650public static new Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right) => CompareGreaterThan(left, right); 655public static Vector256<long> CompareGreaterThanOrEqual(Vector256<long> left, Vector256<long> right) => CompareGreaterThanOrEqual(left, right); 660public static Vector256<long> CompareLessThan(Vector256<long> left, Vector256<long> right) => CompareLessThan(left, right); 665public static Vector256<long> CompareLessThanOrEqual(Vector256<long> left, Vector256<long> right) => CompareLessThanOrEqual(left, right); 670public static Vector256<long> CompareNotEqual(Vector256<long> left, Vector256<long> right) => CompareNotEqual(left, right); 707public static new Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareEqual(left, right); 712public static new Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right) => CompareGreaterThan(left, right); 717public static Vector256<sbyte> CompareGreaterThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareGreaterThanOrEqual(left, right); 722public static Vector256<sbyte> CompareLessThan(Vector256<sbyte> left, Vector256<sbyte> right) => CompareLessThan(left, right); 727public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareLessThanOrEqual(left, right); 732public static Vector256<sbyte> CompareNotEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareNotEqual(left, right); 816public static new Vector256<float> Compare(Vector256<float> left, Vector256<float> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode); 822public static new Vector256<float> CompareEqual(Vector256<float> left, Vector256<float> right) => CompareEqual(left, right); 828public static new Vector256<float> CompareGreaterThan(Vector256<float> left, Vector256<float> right) => CompareGreaterThan(left, right); 834public static new Vector256<float> CompareGreaterThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareGreaterThanOrEqual(left, right); 840public static new Vector256<float> CompareLessThan(Vector256<float> left, Vector256<float> right) => CompareLessThan(left, right); 846public static new Vector256<float> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareLessThanOrEqual(left, right); 852public static new Vector256<float> CompareNotEqual(Vector256<float> left, Vector256<float> right) => CompareNotEqual(left, right); 858public static new Vector256<float> CompareNotGreaterThan(Vector256<float> left, Vector256<float> right) => CompareNotGreaterThan(left, right); 864public static new Vector256<float> CompareNotGreaterThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareNotGreaterThanOrEqual(left, right); 870public static new Vector256<float> CompareNotLessThan(Vector256<float> left, Vector256<float> right) => CompareNotLessThan(left, right); 876public static new Vector256<float> CompareNotLessThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareNotLessThanOrEqual(left, right); 882public static new Vector256<float> CompareOrdered(Vector256<float> left, Vector256<float> right) => CompareOrdered(left, right); 888public static new Vector256<float> CompareUnordered(Vector256<float> left, Vector256<float> right) => CompareUnordered(left, right); 925public static new Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareEqual(left, right); 930public static Vector256<ushort> CompareGreaterThan(Vector256<ushort> left, Vector256<ushort> right) => CompareGreaterThan(left, right); 935public static Vector256<ushort> CompareGreaterThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareGreaterThanOrEqual(left, right); 940public static Vector256<ushort> CompareLessThan(Vector256<ushort> left, Vector256<ushort> right) => CompareLessThan(left, right); 945public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareLessThanOrEqual(left, right); 950public static Vector256<ushort> CompareNotEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareNotEqual(left, right); 987public static new Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right) => CompareEqual(left, right); 992public static Vector256<uint> CompareGreaterThan(Vector256<uint> left, Vector256<uint> right) => CompareGreaterThan(left, right); 997public static Vector256<uint> CompareGreaterThanOrEqual(Vector256<uint> left, Vector256<uint> right) => CompareGreaterThanOrEqual(left, right); 1002public static Vector256<uint> CompareLessThan(Vector256<uint> left, Vector256<uint> right) => CompareLessThan(left, right); 1007public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> left, Vector256<uint> right) => CompareLessThanOrEqual(left, right); 1012public static Vector256<uint> CompareNotEqual(Vector256<uint> left, Vector256<uint> right) => CompareNotEqual(left, right); 1049public static new Vector256<ulong> CompareEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareEqual(left, right); 1054public static Vector256<ulong> CompareGreaterThan(Vector256<ulong> left, Vector256<ulong> right) => CompareGreaterThan(left, right); 1059public static Vector256<ulong> CompareGreaterThanOrEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareGreaterThanOrEqual(left, right); 1064public static Vector256<ulong> CompareLessThan(Vector256<ulong> left, Vector256<ulong> right) => CompareLessThan(left, right); 1069public static Vector256<ulong> CompareLessThanOrEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareLessThanOrEqual(left, right); 1074public static Vector256<ulong> CompareNotEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareNotEqual(left, right); 1131public static Vector256<byte> Compress(Vector256<byte> merge, Vector256<byte> mask, Vector256<byte> value) => Compress(merge, mask, value); 1136public static Vector256<double> Compress(Vector256<double> merge, Vector256<double> mask, Vector256<double> value) => Compress(merge, mask, value); 1141public static Vector256<short> Compress(Vector256<short> merge, Vector256<short> mask, Vector256<short> value) => Compress(merge, mask, value); 1146public static Vector256<int> Compress(Vector256<int> merge, Vector256<int> mask, Vector256<int> value) => Compress(merge, mask, value); 1151public static Vector256<long> Compress(Vector256<long> merge, Vector256<long> mask, Vector256<long> value) => Compress(merge, mask, value); 1156public static Vector256<sbyte> Compress(Vector256<sbyte> merge, Vector256<sbyte> mask, Vector256<sbyte> value) => Compress(merge, mask, value); 1161public static Vector256<float> Compress(Vector256<float> merge, Vector256<float> mask, Vector256<float> value) => Compress(merge, mask, value); 1166public static Vector256<ushort> Compress(Vector256<ushort> merge, Vector256<ushort> mask, Vector256<ushort> value) => Compress(merge, mask, value); 1171public static Vector256<uint> Compress(Vector256<uint> merge, Vector256<uint> mask, Vector256<uint> value) => Compress(merge, mask, value); 1176public static Vector256<ulong> Compress(Vector256<ulong> merge, Vector256<ulong> mask, Vector256<ulong> value) => Compress(merge, mask, value); 1242public static unsafe void CompressStore(byte* address, Vector256<byte> mask, Vector256<byte> source) => CompressStore(address, mask, source); 1248public static unsafe void CompressStore(double* address, Vector256<double> mask, Vector256<double> source) => CompressStore(address, mask, source); 1254public static unsafe void CompressStore(short* address, Vector256<short> mask, Vector256<short> source) => CompressStore(address, mask, source); 1260public static unsafe void CompressStore(int* address, Vector256<int> mask, Vector256<int> source) => CompressStore(address, mask, source); 1266public static unsafe void CompressStore(long* address, Vector256<long> mask, Vector256<long> source) => CompressStore(address, mask, source); 1272public static unsafe void CompressStore(sbyte* address, Vector256<sbyte> mask, Vector256<sbyte> source) => CompressStore(address, mask, source); 1278public static unsafe void CompressStore(float* address, Vector256<float> mask, Vector256<float> source) => CompressStore(address, mask, source); 1284public static unsafe void CompressStore(ushort* address, Vector256<ushort> mask, Vector256<ushort> source) => CompressStore(address, mask, source); 1290public static unsafe void CompressStore(uint* address, Vector256<uint> mask, Vector256<uint> source) => CompressStore(address, mask, source); 1296public static unsafe void CompressStore(ulong* address, Vector256<ulong> mask, Vector256<ulong> source) => CompressStore(address, mask, source); 1402public static Vector128<byte> ConvertToVector128Byte(Vector256<int> value) => ConvertToVector128Byte(value); 1407public static Vector128<byte> ConvertToVector128Byte(Vector256<long> value) => ConvertToVector128Byte(value); 1412public static Vector128<byte> ConvertToVector128Byte(Vector256<short> value) => ConvertToVector128Byte(value); 1417public static Vector128<byte> ConvertToVector128Byte(Vector256<uint> value) => ConvertToVector128Byte(value); 1422public static Vector128<byte> ConvertToVector128Byte(Vector256<ulong> value) => ConvertToVector128Byte(value); 1427public static Vector128<byte> ConvertToVector128Byte(Vector256<ushort> value) => ConvertToVector128Byte(value); 1448public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<uint> value) => ConvertToVector128ByteWithSaturation(value); 1453public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<ulong> value) => ConvertToVector128ByteWithSaturation(value); 1458public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<ushort> value) => ConvertToVector128ByteWithSaturation(value); 1500public static Vector128<short> ConvertToVector128Int16(Vector256<int> value) => ConvertToVector128Int16(value); 1505public static Vector128<short> ConvertToVector128Int16(Vector256<long> value) => ConvertToVector128Int16(value); 1510public static Vector128<short> ConvertToVector128Int16(Vector256<uint> value) => ConvertToVector128Int16(value); 1515public static Vector128<short> ConvertToVector128Int16(Vector256<ulong> value) => ConvertToVector128Int16(value); 1531public static Vector128<short> ConvertToVector128Int16WithSaturation(Vector256<int> value) => ConvertToVector128Int16WithSaturation(value); 1536public static Vector128<short> ConvertToVector128Int16WithSaturation(Vector256<long> value) => ConvertToVector128Int16WithSaturation(value); 1552public static Vector128<int> ConvertToVector128Int32(Vector256<long> value) => ConvertToVector128Int32(value); 1557public static Vector128<int> ConvertToVector128Int32(Vector256<ulong> value) => ConvertToVector128Int32(value); 1568public static Vector128<int> ConvertToVector128Int32WithSaturation(Vector256<long> value) => ConvertToVector128Int32WithSaturation(value); 1626public static Vector128<sbyte> ConvertToVector128SByte(Vector256<int> value) => ConvertToVector128SByte(value); 1631public static Vector128<sbyte> ConvertToVector128SByte(Vector256<long> value) => ConvertToVector128SByte(value); 1636public static Vector128<sbyte> ConvertToVector128SByte(Vector256<short> value) => ConvertToVector128SByte(value); 1641public static Vector128<sbyte> ConvertToVector128SByte(Vector256<uint> value) => ConvertToVector128SByte(value); 1646public static Vector128<sbyte> ConvertToVector128SByte(Vector256<ulong> value) => ConvertToVector128SByte(value); 1651public static Vector128<sbyte> ConvertToVector128SByte(Vector256<ushort> value) => ConvertToVector128SByte(value); 1672public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<int> value) => ConvertToVector128SByteWithSaturation(value); 1677public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<long> value) => ConvertToVector128SByteWithSaturation(value); 1682public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<short> value) => ConvertToVector128SByteWithSaturation(value); 1703public static Vector128<float> ConvertToVector128Single(Vector256<long> value) => ConvertToVector128Single(value); 1708public static Vector128<float> ConvertToVector128Single(Vector256<ulong> value) => ConvertToVector128Single(value); 1734public static Vector128<ushort> ConvertToVector128UInt16(Vector256<int> value) => ConvertToVector128UInt16(value); 1739public static Vector128<ushort> ConvertToVector128UInt16(Vector256<long> value) => ConvertToVector128UInt16(value); 1744public static Vector128<ushort> ConvertToVector128UInt16(Vector256<uint> value) => ConvertToVector128UInt16(value); 1749public static Vector128<ushort> ConvertToVector128UInt16(Vector256<ulong> value) => ConvertToVector128UInt16(value); 1765public static Vector128<ushort> ConvertToVector128UInt16WithSaturation(Vector256<uint> value) => ConvertToVector128UInt16WithSaturation(value); 1770public static Vector128<ushort> ConvertToVector128UInt16WithSaturation(Vector256<ulong> value) => ConvertToVector128UInt16WithSaturation(value); 1796public static Vector128<uint> ConvertToVector128UInt32(Vector256<double> value) => ConvertToVector128UInt32(value); 1801public static Vector128<uint> ConvertToVector128UInt32(Vector256<long> value) => ConvertToVector128UInt32(value); 1806public static Vector128<uint> ConvertToVector128UInt32(Vector256<ulong> value) => ConvertToVector128UInt32(value); 1817public static Vector128<uint> ConvertToVector128UInt32WithSaturation(Vector256<ulong> value) => ConvertToVector128UInt32WithSaturation(value); 1833public static Vector128<uint> ConvertToVector128UInt32WithTruncation(Vector256<double> value) => ConvertToVector128UInt32WithTruncation(value); 1861public static Vector256<double> ConvertToVector256Double(Vector128<uint> value) => ConvertToVector256Double(value); 1866public static Vector256<double> ConvertToVector256Double(Vector256<long> value) => ConvertToVector256Double(value); 1871public static Vector256<double> ConvertToVector256Double(Vector256<ulong> value) => ConvertToVector256Double(value); 1877public static Vector256<long> ConvertToVector256Int64(Vector128<float> value) => ConvertToVector256Int64(value); 1882public static Vector256<long> ConvertToVector256Int64(Vector256<double> value) => ConvertToVector256Int64(value); 1888public static Vector256<long> ConvertToVector256Int64WithTruncation(Vector128<float> value) => ConvertToVector256Int64WithTruncation(value); 1893public static Vector256<long> ConvertToVector256Int64WithTruncation(Vector256<double> value) => ConvertToVector256Int64WithTruncation(value); 1899public static Vector256<float> ConvertToVector256Single(Vector256<uint> value) => ConvertToVector256Single(value); 1905public static Vector256<uint> ConvertToVector256UInt32(Vector256<float> value) => ConvertToVector256UInt32(value); 1911public static Vector256<uint> ConvertToVector256UInt32WithTruncation(Vector256<float> value) => ConvertToVector256UInt32WithTruncation(value); 1917public static Vector256<ulong> ConvertToVector256UInt64(Vector128<float> value) => ConvertToVector256UInt64(value); 1922public static Vector256<ulong> ConvertToVector256UInt64(Vector256<double> value) => ConvertToVector256UInt64(value); 1928public static Vector256<ulong> ConvertToVector256UInt64WithTruncation(Vector128<float> value) => ConvertToVector256UInt64WithTruncation(value); 1933public static Vector256<ulong> ConvertToVector256UInt64WithTruncation(Vector256<double> value) => ConvertToVector256UInt64WithTruncation(value); 1960public static Vector256<int> DetectConflicts(Vector256<int> value) => DetectConflicts(value); 1965public static Vector256<long> DetectConflicts(Vector256<long> value) => DetectConflicts(value); 1970public static Vector256<uint> DetectConflicts(Vector256<uint> value) => DetectConflicts(value); 1975public static Vector256<ulong> DetectConflicts(Vector256<ulong> value) => DetectConflicts(value); 2043public static Vector256<byte> Expand(Vector256<byte> merge, Vector256<byte> mask, Vector256<byte> value) => Expand(merge, mask, value); 2048public static Vector256<double> Expand(Vector256<double> merge, Vector256<double> mask, Vector256<double> value) => Expand(merge, mask, value); 2053public static Vector256<short> Expand(Vector256<short> merge, Vector256<short> mask, Vector256<short> value) => Expand(merge, mask, value); 2058public static Vector256<int> Expand(Vector256<int> merge, Vector256<int> mask, Vector256<int> value) => Expand(merge, mask, value); 2063public static Vector256<long> Expand(Vector256<long> merge, Vector256<long> mask, Vector256<long> value) => Expand(merge, mask, value); 2068public static Vector256<sbyte> Expand(Vector256<sbyte> merge, Vector256<sbyte> mask, Vector256<sbyte> value) => Expand(merge, mask, value); 2073public static Vector256<float> Expand(Vector256<float> merge, Vector256<float> mask, Vector256<float> value) => Expand(merge, mask, value); 2078public static Vector256<ushort> Expand(Vector256<ushort> merge, Vector256<ushort> mask, Vector256<ushort> value) => Expand(merge, mask, value); 2083public static Vector256<uint> Expand(Vector256<uint> merge, Vector256<uint> mask, Vector256<uint> value) => Expand(merge, mask, value); 2088public static Vector256<ulong> Expand(Vector256<ulong> merge, Vector256<ulong> mask, Vector256<ulong> value) => Expand(merge, mask, value); 2165public static unsafe Vector256<byte> ExpandLoad(byte* address, Vector256<byte> mask, Vector256<byte> merge) => ExpandLoad(address, mask, merge); 2172public static unsafe Vector256<double> ExpandLoad(double* address, Vector256<double> mask, Vector256<double> merge) => ExpandLoad(address, mask, merge); 2179public static unsafe Vector256<short> ExpandLoad(short* address, Vector256<short> mask, Vector256<short> merge) => ExpandLoad(address, mask, merge); 2186public static unsafe Vector256<int> ExpandLoad(int* address, Vector256<int> mask, Vector256<int> merge) => ExpandLoad(address, mask, merge); 2193public static unsafe Vector256<long> ExpandLoad(long* address, Vector256<long> mask, Vector256<long> merge) => ExpandLoad(address, mask, merge); 2200public static unsafe Vector256<sbyte> ExpandLoad(sbyte* address, Vector256<sbyte> mask, Vector256<sbyte> merge) => ExpandLoad(address, mask, merge); 2207public static unsafe Vector256<float> ExpandLoad(float* address, Vector256<float> mask, Vector256<float> merge) => ExpandLoad(address, mask, merge); 2214public static unsafe Vector256<ushort> ExpandLoad(ushort* address, Vector256<ushort> mask, Vector256<ushort> merge) => ExpandLoad(address, mask, merge); 2221public static unsafe Vector256<uint> ExpandLoad(uint* address, Vector256<uint> mask, Vector256<uint> merge) => ExpandLoad(address, mask, merge); 2228public static unsafe Vector256<ulong> ExpandLoad(ulong* address, Vector256<ulong> mask, Vector256<ulong> merge) => ExpandLoad(address, mask, merge); 2245public static Vector256<double> Fixup(Vector256<double> left, Vector256<double> right, Vector256<long> table, [ConstantExpected] byte control) => Fixup(left, right, table, control); 2250public static Vector256<float> Fixup(Vector256<float> left, Vector256<float> right, Vector256<int> table, [ConstantExpected] byte control) => Fixup(left, right, table, control); 2320public static Vector256<double> GetExponent(Vector256<double> value) => GetExponent(value); 2325public static Vector256<float> GetExponent(Vector256<float> value) => GetExponent(value); 2365public static Vector256<double> GetMantissa(Vector256<double> value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); 2370public static Vector256<float> GetMantissa(Vector256<float> value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); 2420public static Vector256<int> LeadingZeroCount(Vector256<int> value) => LeadingZeroCount(value); 2425public static Vector256<long> LeadingZeroCount(Vector256<long> value) => LeadingZeroCount(value); 2430public static Vector256<uint> LeadingZeroCount(Vector256<uint> value) => LeadingZeroCount(value); 2435public static Vector256<ulong> LeadingZeroCount(Vector256<ulong> value) => LeadingZeroCount(value); 2512public static unsafe Vector256<byte> MaskLoad(byte* address, Vector256<byte> mask, Vector256<byte> merge) => MaskLoad(address, mask, merge); 2519public static unsafe Vector256<double> MaskLoad(double* address, Vector256<double> mask, Vector256<double> merge) => MaskLoad(address, mask, merge); 2526public static unsafe Vector256<short> MaskLoad(short* address, Vector256<short> mask, Vector256<short> merge) => MaskLoad(address, mask, merge); 2532public static unsafe Vector256<int> MaskLoad(int* address, Vector256<int> mask, Vector256<int> merge) => MaskLoad(address, mask, merge); 2539public static unsafe Vector256<long> MaskLoad(long* address, Vector256<long> mask, Vector256<long> merge) => MaskLoad(address, mask, merge); 2546public static unsafe Vector256<sbyte> MaskLoad(sbyte* address, Vector256<sbyte> mask, Vector256<sbyte> merge) => MaskLoad(address, mask, merge); 2553public static unsafe Vector256<float> MaskLoad(float* address, Vector256<float> mask, Vector256<float> merge) => MaskLoad(address, mask, merge); 2560public static unsafe Vector256<ushort> MaskLoad(ushort* address, Vector256<ushort> mask, Vector256<ushort> merge) => MaskLoad(address, mask, merge); 2567public static unsafe Vector256<uint> MaskLoad(uint* address, Vector256<uint> mask, Vector256<uint> merge) => MaskLoad(address, mask, merge); 2574public static unsafe Vector256<ulong> MaskLoad(ulong* address, Vector256<ulong> mask, Vector256<ulong> merge) => MaskLoad(address, mask, merge); 2623public static unsafe Vector256<double> MaskLoadAligned(double* address, Vector256<double> mask, Vector256<double> merge) => MaskLoadAligned(address, mask, merge); 2630public static unsafe Vector256<int> MaskLoadAligned(int* address, Vector256<int> mask, Vector256<int> merge) => MaskLoadAligned(address, mask, merge); 2637public static unsafe Vector256<long> MaskLoadAligned(long* address, Vector256<long> mask, Vector256<long> merge) => MaskLoadAligned(address, mask, merge); 2644public static unsafe Vector256<float> MaskLoadAligned(float* address, Vector256<float> mask, Vector256<float> merge) => MaskLoadAligned(address, mask, merge); 2651public static unsafe Vector256<uint> MaskLoadAligned(uint* address, Vector256<uint> mask, Vector256<uint> merge) => MaskLoadAligned(address, mask, merge); 2658public static unsafe Vector256<ulong> MaskLoadAligned(ulong* address, Vector256<ulong> mask, Vector256<ulong> merge) => MaskLoadAligned(address, mask, merge); 2724public static unsafe void MaskStore(byte* address, Vector256<byte> mask, Vector256<byte> source) => MaskStore(address, mask, source); 2730public static new unsafe void MaskStore(double* address, Vector256<double> mask, Vector256<double> source) => MaskStore(address, mask, source); 2736public static unsafe void MaskStore(short* address, Vector256<short> mask, Vector256<short> source) => MaskStore(address, mask, source); 2742public static new unsafe void MaskStore(int* address, Vector256<int> mask, Vector256<int> source) => MaskStore(address, mask, source); 2748public static new unsafe void MaskStore(long* address, Vector256<long> mask, Vector256<long> source) => MaskStore(address, mask, source); 2754public static unsafe void MaskStore(sbyte* address, Vector256<sbyte> mask, Vector256<sbyte> source) => MaskStore(address, mask, source); 2760public static new unsafe void MaskStore(float* address, Vector256<float> mask, Vector256<float> source) => MaskStore(address, mask, source); 2766public static unsafe void MaskStore(ushort* address, Vector256<ushort> mask, Vector256<ushort> source) => MaskStore(address, mask, source); 2772public static new unsafe void MaskStore(uint* address, Vector256<uint> mask, Vector256<uint> source) => MaskStore(address, mask, source); 2778public static new unsafe void MaskStore(ulong* address, Vector256<ulong> mask, Vector256<ulong> source) => MaskStore(address, mask, source); 2820public static unsafe void MaskStoreAligned(double* address, Vector256<double> mask, Vector256<double> source) => MaskStoreAligned(address, mask, source); 2826public static unsafe void MaskStoreAligned(int* address, Vector256<int> mask, Vector256<int> source) => MaskStoreAligned(address, mask, source); 2832public static unsafe void MaskStoreAligned(long* address, Vector256<long> mask, Vector256<long> source) => MaskStoreAligned(address, mask, source); 2838public static unsafe void MaskStoreAligned(float* address, Vector256<float> mask, Vector256<float> source) => MaskStoreAligned(address, mask, source); 2844public static unsafe void MaskStoreAligned(uint* address, Vector256<uint> mask, Vector256<uint> source) => MaskStoreAligned(address, mask, source); 2850public static unsafe void MaskStoreAligned(ulong* address, Vector256<ulong> mask, Vector256<ulong> source) => MaskStoreAligned(address, mask, source); 2867public static Vector256<long> Max(Vector256<long> left, Vector256<long> right) => Max(left, right); 2872public static Vector256<ulong> Max(Vector256<ulong> left, Vector256<ulong> right) => Max(left, right); 2889public static Vector256<long> Min(Vector256<long> left, Vector256<long> right) => Min(left, right); 2894public static Vector256<ulong> Min(Vector256<ulong> left, Vector256<ulong> right) => Min(left, right); 2951public static new int MoveMask(Vector256<byte> value) => MoveMask(value); 2956public static new int MoveMask(Vector256<double> value) => MoveMask(value); 2961public static int MoveMask(Vector256<short> value) => MoveMask(value); 2966public static int MoveMask(Vector256<int> value) => MoveMask(value); 2971public static int MoveMask(Vector256<long> value) => MoveMask(value); 2976public static new int MoveMask(Vector256<sbyte> value) => MoveMask(value); 2981public static new int MoveMask(Vector256<float> value) => MoveMask(value); 2986public static int MoveMask(Vector256<ushort> value) => MoveMask(value); 2991public static int MoveMask(Vector256<uint> value) => MoveMask(value); 2996public static int MoveMask(Vector256<ulong> value) => MoveMask(value); 3013public static Vector256<long> MultiplyLow(Vector256<long> left, Vector256<long> right) => MultiplyLow(left, right); 3018public static Vector256<ulong> MultiplyLow(Vector256<ulong> left, Vector256<ulong> right) => MultiplyLow(left, right); 3046public static Vector256<byte> MultiShift(Vector256<byte> control, Vector256<ulong> value) => MultiShift(control, value); 3051public static Vector256<sbyte> MultiShift(Vector256<sbyte> control, Vector256<long> value) => MultiShift(control, value); 3058public static Vector256<short> PermuteVar16x16(Vector256<short> left, Vector256<short> control) => PermuteVar16x16(left, control); 3064public static Vector256<ushort> PermuteVar16x16(Vector256<ushort> left, Vector256<ushort> control) => PermuteVar16x16(left, control); 3071public static Vector256<short> PermuteVar16x16x2(Vector256<short> lower, Vector256<short> indices, Vector256<short> upper) => PermuteVar16x16x2(lower, indices, upper); 3077public static Vector256<ushort> PermuteVar16x16x2(Vector256<ushort> lower, Vector256<ushort> indices, Vector256<ushort> upper) => PermuteVar16x16x2(lower, indices, upper); 3129public static Vector256<byte> PermuteVar32x8(Vector256<byte> left, Vector256<byte> control) => PermuteVar32x8(left, control); 3135public static Vector256<sbyte> PermuteVar32x8(Vector256<sbyte> left, Vector256<sbyte> control) => PermuteVar32x8(left, control); 3142public static Vector256<byte> PermuteVar32x8x2(Vector256<byte> lower, Vector256<byte> indices, Vector256<byte> upper) => PermuteVar32x8x2(lower, indices, upper); 3148public static Vector256<sbyte> PermuteVar32x8x2(Vector256<sbyte> lower, Vector256<sbyte> indices, Vector256<sbyte> upper) => PermuteVar32x8x2(lower, indices, upper); 3173public static Vector256<double> PermuteVar4x64(Vector256<double> value, Vector256<long> control) => PermuteVar4x64(value, control); 3179public static Vector256<long> PermuteVar4x64(Vector256<long> value, Vector256<long> control) => PermuteVar4x64(value, control); 3185public static Vector256<ulong> PermuteVar4x64(Vector256<ulong> value, Vector256<ulong> control) => PermuteVar4x64(value, control); 3192public static Vector256<double> PermuteVar4x64x2(Vector256<double> lower, Vector256<long> indices, Vector256<double> upper) => PermuteVar4x64x2(lower, indices, upper); 3198public static Vector256<long> PermuteVar4x64x2(Vector256<long> lower, Vector256<long> indices, Vector256<long> upper) => PermuteVar4x64x2(lower, indices, upper); 3204public static Vector256<ulong> PermuteVar4x64x2(Vector256<ulong> lower, Vector256<ulong> indices, Vector256<ulong> upper) => PermuteVar4x64x2(lower, indices, upper); 3237public static Vector256<float> PermuteVar8x32x2(Vector256<float> lower, Vector256<int> indices, Vector256<float> upper) => PermuteVar8x32x2(lower, indices, upper); 3243public static Vector256<int> PermuteVar8x32x2(Vector256<int> lower, Vector256<int> indices, Vector256<int> upper) => PermuteVar8x32x2(lower, indices, upper); 3249public static Vector256<uint> PermuteVar8x32x2(Vector256<uint> lower, Vector256<uint> indices, Vector256<uint> upper) => PermuteVar8x32x2(lower, indices, upper); 3266public static Vector256<double> Range(Vector256<double> left, Vector256<double> right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); 3271public static Vector256<float> Range(Vector256<float> left, Vector256<float> right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); 3299public static Vector256<double> Reciprocal14(Vector256<double> value) => Reciprocal14(value); 3304public static Vector256<float> Reciprocal14(Vector256<float> value) => Reciprocal14(value); 3344public static Vector256<double> ReciprocalSqrt14(Vector256<double> value) => ReciprocalSqrt14(value); 3349public static Vector256<float> ReciprocalSqrt14(Vector256<float> value) => ReciprocalSqrt14(value); 3389public static Vector256<double> Reduce(Vector256<double> value, [ConstantExpected] byte control) => Reduce(value, control); 3394public static Vector256<float> Reduce(Vector256<float> value, [ConstantExpected] byte control) => Reduce(value, control); 3445public static Vector256<int> RotateLeft(Vector256<int> value, [ConstantExpected] byte count) => RotateLeft(value, count); 3450public static Vector256<long> RotateLeft(Vector256<long> value, [ConstantExpected] byte count) => RotateLeft(value, count); 3455public static Vector256<uint> RotateLeft(Vector256<uint> value, [ConstantExpected] byte count) => RotateLeft(value, count); 3460public static Vector256<ulong> RotateLeft(Vector256<ulong> value, [ConstantExpected] byte count) => RotateLeft(value, count); 3487public static Vector256<int> RotateLeftVariable(Vector256<int> value, Vector256<uint> count) => RotateLeftVariable(value, count); 3492public static Vector256<long> RotateLeftVariable(Vector256<long> value, Vector256<ulong> count) => RotateLeftVariable(value, count); 3497public static Vector256<uint> RotateLeftVariable(Vector256<uint> value, Vector256<uint> count) => RotateLeftVariable(value, count); 3502public static Vector256<ulong> RotateLeftVariable(Vector256<ulong> value, Vector256<ulong> count) => RotateLeftVariable(value, count); 3529public static Vector256<int> RotateRight(Vector256<int> value, [ConstantExpected] byte count) => RotateRight(value, count); 3534public static Vector256<long> RotateRight(Vector256<long> value, [ConstantExpected] byte count) => RotateRight(value, count); 3539public static Vector256<uint> RotateRight(Vector256<uint> value, [ConstantExpected] byte count) => RotateRight(value, count); 3544public static Vector256<ulong> RotateRight(Vector256<ulong> value, [ConstantExpected] byte count) => RotateRight(value, count); 3571public static Vector256<int> RotateRightVariable(Vector256<int> value, Vector256<uint> count) => RotateRightVariable(value, count); 3576public static Vector256<long> RotateRightVariable(Vector256<long> value, Vector256<ulong> count) => RotateRightVariable(value, count); 3581public static Vector256<uint> RotateRightVariable(Vector256<uint> value, Vector256<uint> count) => RotateRightVariable(value, count); 3586public static Vector256<ulong> RotateRightVariable(Vector256<ulong> value, Vector256<ulong> count) => RotateRightVariable(value, count); 3603public static Vector256<double> RoundScale(Vector256<double> value, [ConstantExpected] byte control) => RoundScale(value, control); 3608public static Vector256<float> RoundScale(Vector256<float> value, [ConstantExpected] byte control) => RoundScale(value, control); 3648public static Vector256<double> Scale(Vector256<double> left, Vector256<double> right) => Scale(left, right); 3653public static Vector256<float> Scale(Vector256<float> left, Vector256<float> right) => Scale(left, right); 3691public static Vector256<short> ShiftLeftLogicalVariable(Vector256<short> value, Vector256<ushort> count) => ShiftLeftLogicalVariable(value, count); 3696public static Vector256<ushort> ShiftLeftLogicalVariable(Vector256<ushort> value, Vector256<ushort> count) => ShiftLeftLogicalVariable(value, count); 3713public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); 3718public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, Vector128<long> count) => ShiftRightArithmetic(value, count); 3735public static Vector256<long> ShiftRightArithmeticVariable(Vector256<long> value, Vector256<ulong> count) => ShiftRightArithmeticVariable(value, count); 3740public static Vector256<short> ShiftRightArithmeticVariable(Vector256<short> value, Vector256<ushort> count) => ShiftRightArithmeticVariable(value, count); 3757public static Vector256<short> ShiftRightLogicalVariable(Vector256<short> value, Vector256<ushort> count) => ShiftRightLogicalVariable(value, count); 3762public static Vector256<ushort> ShiftRightLogicalVariable(Vector256<ushort> value, Vector256<ushort> count) => ShiftRightLogicalVariable(value, count); 3768public static Vector256<double> Shuffle2x128(Vector256<double> left, Vector256<double> right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); 3773public static Vector256<float> Shuffle2x128(Vector256<float> left, Vector256<float> right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); 3778public static Vector256<int> Shuffle2x128(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); 3783public static Vector256<long> Shuffle2x128(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); 3788public static Vector256<uint> Shuffle2x128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); 3793public static Vector256<ulong> Shuffle2x128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); 3826public static Vector256<ushort> SumAbsoluteDifferencesInBlock32(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte control) => SumAbsoluteDifferencesInBlock32(left, right, control); 3890public static Vector256<byte> TernaryLogic(Vector256<byte> a, Vector256<byte> b, Vector256<byte> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 3896public static Vector256<double> TernaryLogic(Vector256<double> a, Vector256<double> b, Vector256<double> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 3902public static Vector256<float> TernaryLogic(Vector256<float> a, Vector256<float> b, Vector256<float> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 3907public static Vector256<int> TernaryLogic(Vector256<int> a, Vector256<int> b, Vector256<int> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 3912public static Vector256<long> TernaryLogic(Vector256<long> a, Vector256<long> b, Vector256<long> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 3918public static Vector256<sbyte> TernaryLogic(Vector256<sbyte> a, Vector256<sbyte> b, Vector256<sbyte> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 3924public static Vector256<short> TernaryLogic(Vector256<short> a, Vector256<short> b, Vector256<short> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 3929public static Vector256<uint> TernaryLogic(Vector256<uint> a, Vector256<uint> b, Vector256<uint> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 3934public static Vector256<ulong> TernaryLogic(Vector256<ulong> a, Vector256<ulong> b, Vector256<ulong> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 3940public static Vector256<ushort> TernaryLogic(Vector256<ushort> a, Vector256<ushort> b, Vector256<ushort> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 4188public static Vector256<float> ConvertToVector256Single(Vector512<long> value) => ConvertToVector256Single(value); 4193public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value) => ConvertToVector256Single(value); 4198public static Vector256<float> ConvertToVector256Single(Vector512<long> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); 4203public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); 4230public static Vector512<long> ConvertToVector512Int64(Vector256<float> value) => ConvertToVector512Int64(value); 4240public static Vector512<long> ConvertToVector512Int64(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int64(value, mode); 4251public static Vector512<long> ConvertToVector512Int64WithTruncation(Vector256<float> value) => ConvertToVector512Int64WithTruncation(value); 4262public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value) => ConvertToVector512UInt64(value); 4272public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt64(value, mode); 4283public static Vector512<ulong> ConvertToVector512UInt64WithTruncation(Vector256<float> value) => ConvertToVector512UInt64WithTruncation(value); 4380public static new Vector256<int> ExtractVector256(Vector512<int> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 4385public static new Vector256<uint> ExtractVector256(Vector512<uint> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 4390public static new Vector256<float> ExtractVector256(Vector512<float> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 4412public static new Vector512<int> InsertVector256(Vector512<int> value, Vector256<int> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4417public static new Vector512<uint> InsertVector256(Vector512<uint> value, Vector256<uint> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4422public static new Vector512<float> InsertVector256(Vector512<float> value, Vector256<float> data, [ConstantExpected] byte index) => InsertVector256(value, data, index);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Avx10v2.cs (14)
29public static Vector256<double> MinMax(Vector256<double> left, Vector256<double> right, [ConstantExpected] byte control) => MinMax(left, right, control); 39public static Vector256<float> MinMax(Vector256<float> left, Vector256<float> right, [ConstantExpected] byte control) => MinMax(left, right, control); 59public static Vector256<int> ConvertToSByteWithSaturationAndZeroExtendToInt32(Vector256<float> value) => ConvertToSByteWithSaturationAndZeroExtendToInt32(value); 69public static Vector256<int> ConvertToByteWithSaturationAndZeroExtendToInt32(Vector256<float> value) => ConvertToByteWithSaturationAndZeroExtendToInt32(value); 79public static Vector256<int> ConvertToSByteWithTruncatedSaturationAndZeroExtendToInt32(Vector256<float> value) => ConvertToSByteWithTruncatedSaturationAndZeroExtendToInt32(value); 89public static Vector256<int> ConvertToByteWithTruncatedSaturationAndZeroExtendToInt32(Vector256<float> value) => ConvertToByteWithTruncatedSaturationAndZeroExtendToInt32(value);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Avx2.cs (774)
38public static Vector256<byte> Abs(Vector256<sbyte> value) => Abs(value); 44public static Vector256<ushort> Abs(Vector256<short> value) => Abs(value); 50public static Vector256<uint> Abs(Vector256<int> value) => Abs(value); 57public static Vector256<sbyte> Add(Vector256<sbyte> left, Vector256<sbyte> right) => Add(left, right); 63public static Vector256<byte> Add(Vector256<byte> left, Vector256<byte> right) => Add(left, right); 69public static Vector256<short> Add(Vector256<short> left, Vector256<short> right) => Add(left, right); 75public static Vector256<ushort> Add(Vector256<ushort> left, Vector256<ushort> right) => Add(left, right); 81public static Vector256<int> Add(Vector256<int> left, Vector256<int> right) => Add(left, right); 87public static Vector256<uint> Add(Vector256<uint> left, Vector256<uint> right) => Add(left, right); 93public static Vector256<long> Add(Vector256<long> left, Vector256<long> right) => Add(left, right); 99public static Vector256<ulong> Add(Vector256<ulong> left, Vector256<ulong> right) => Add(left, right); 106public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<sbyte> right) => AddSaturate(left, right); 112public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<byte> right) => AddSaturate(left, right); 118public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<short> right) => AddSaturate(left, right); 124public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<ushort> right) => AddSaturate(left, right); 131public static Vector256<sbyte> AlignRight(Vector256<sbyte> left, Vector256<sbyte> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); 137public static Vector256<byte> AlignRight(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); 144public static Vector256<short> AlignRight(Vector256<short> left, Vector256<short> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); 151public static Vector256<ushort> AlignRight(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); 158public static Vector256<int> AlignRight(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); 165public static Vector256<uint> AlignRight(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); 172public static Vector256<long> AlignRight(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); 179public static Vector256<ulong> AlignRight(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); 185public static Vector256<sbyte> And(Vector256<sbyte> left, Vector256<sbyte> right) => And(left, right); 190public static Vector256<byte> And(Vector256<byte> left, Vector256<byte> right) => And(left, right); 195public static Vector256<short> And(Vector256<short> left, Vector256<short> right) => And(left, right); 200public static Vector256<ushort> And(Vector256<ushort> left, Vector256<ushort> right) => And(left, right); 206public static Vector256<int> And(Vector256<int> left, Vector256<int> right) => And(left, right); 212public static Vector256<uint> And(Vector256<uint> left, Vector256<uint> right) => And(left, right); 218public static Vector256<long> And(Vector256<long> left, Vector256<long> right) => And(left, right); 224public static Vector256<ulong> And(Vector256<ulong> left, Vector256<ulong> right) => And(left, right); 230public static Vector256<sbyte> AndNot(Vector256<sbyte> left, Vector256<sbyte> right) => AndNot(left, right); 235public static Vector256<byte> AndNot(Vector256<byte> left, Vector256<byte> right) => AndNot(left, right); 240public static Vector256<short> AndNot(Vector256<short> left, Vector256<short> right) => AndNot(left, right); 245public static Vector256<ushort> AndNot(Vector256<ushort> left, Vector256<ushort> right) => AndNot(left, right); 251public static Vector256<int> AndNot(Vector256<int> left, Vector256<int> right) => AndNot(left, right); 257public static Vector256<uint> AndNot(Vector256<uint> left, Vector256<uint> right) => AndNot(left, right); 263public static Vector256<long> AndNot(Vector256<long> left, Vector256<long> right) => AndNot(left, right); 269public static Vector256<ulong> AndNot(Vector256<ulong> left, Vector256<ulong> right) => AndNot(left, right); 276public static Vector256<byte> Average(Vector256<byte> left, Vector256<byte> right) => Average(left, right); 282public static Vector256<ushort> Average(Vector256<ushort> left, Vector256<ushort> right) => Average(left, right); 298public static Vector256<short> Blend(Vector256<short> left, Vector256<short> right, [ConstantExpected] byte control) => Blend(left, right, control); 303public static Vector256<ushort> Blend(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected] byte control) => Blend(left, right, control); 308public static Vector256<int> Blend(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte control) => Blend(left, right, control); 313public static Vector256<uint> Blend(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte control) => Blend(left, right, control); 319public static Vector256<sbyte> BlendVariable(Vector256<sbyte> left, Vector256<sbyte> right, Vector256<sbyte> mask) => BlendVariable(left, right, mask); 324public static Vector256<byte> BlendVariable(Vector256<byte> left, Vector256<byte> right, Vector256<byte> mask) => BlendVariable(left, right, mask); 330public static Vector256<short> BlendVariable(Vector256<short> left, Vector256<short> right, Vector256<short> mask) => BlendVariable(left, right, mask); 336public static Vector256<ushort> BlendVariable(Vector256<ushort> left, Vector256<ushort> right, Vector256<ushort> mask) => BlendVariable(left, right, mask); 342public static Vector256<int> BlendVariable(Vector256<int> left, Vector256<int> right, Vector256<int> mask) => BlendVariable(left, right, mask); 348public static Vector256<uint> BlendVariable(Vector256<uint> left, Vector256<uint> right, Vector256<uint> mask) => BlendVariable(left, right, mask); 354public static Vector256<long> BlendVariable(Vector256<long> left, Vector256<long> right, Vector256<long> mask) => BlendVariable(left, right, mask); 360public static Vector256<ulong> BlendVariable(Vector256<ulong> left, Vector256<ulong> right, Vector256<ulong> mask) => BlendVariable(left, right, mask); 491public static Vector256<byte> BroadcastScalarToVector256(Vector128<byte> value) => BroadcastScalarToVector256(value); 497public static Vector256<sbyte> BroadcastScalarToVector256(Vector128<sbyte> value) => BroadcastScalarToVector256(value); 503public static Vector256<short> BroadcastScalarToVector256(Vector128<short> value) => BroadcastScalarToVector256(value); 509public static Vector256<ushort> BroadcastScalarToVector256(Vector128<ushort> value) => BroadcastScalarToVector256(value); 515public static Vector256<int> BroadcastScalarToVector256(Vector128<int> value) => BroadcastScalarToVector256(value); 521public static Vector256<uint> BroadcastScalarToVector256(Vector128<uint> value) => BroadcastScalarToVector256(value); 527public static Vector256<long> BroadcastScalarToVector256(Vector128<long> value) => BroadcastScalarToVector256(value); 533public static Vector256<ulong> BroadcastScalarToVector256(Vector128<ulong> value) => BroadcastScalarToVector256(value); 539public static Vector256<float> BroadcastScalarToVector256(Vector128<float> value) => BroadcastScalarToVector256(value); 545public static Vector256<double> BroadcastScalarToVector256(Vector128<double> value) => BroadcastScalarToVector256(value); 553public static unsafe Vector256<byte> BroadcastScalarToVector256(byte* source) => BroadcastScalarToVector256(source); 561public static unsafe Vector256<sbyte> BroadcastScalarToVector256(sbyte* source) => BroadcastScalarToVector256(source); 569public static unsafe Vector256<short> BroadcastScalarToVector256(short* source) => BroadcastScalarToVector256(source); 577public static unsafe Vector256<ushort> BroadcastScalarToVector256(ushort* source) => BroadcastScalarToVector256(source); 585public static unsafe Vector256<int> BroadcastScalarToVector256(int* source) => BroadcastScalarToVector256(source); 593public static unsafe Vector256<uint> BroadcastScalarToVector256(uint* source) => BroadcastScalarToVector256(source); 601public static unsafe Vector256<long> BroadcastScalarToVector256(long* source) => BroadcastScalarToVector256(source); 609public static unsafe Vector256<ulong> BroadcastScalarToVector256(ulong* source) => BroadcastScalarToVector256(source); 617public static unsafe Vector256<sbyte> BroadcastVector128ToVector256(sbyte* address) => BroadcastVector128ToVector256(address); 625public static unsafe Vector256<byte> BroadcastVector128ToVector256(byte* address) => BroadcastVector128ToVector256(address); 633public static unsafe Vector256<short> BroadcastVector128ToVector256(short* address) => BroadcastVector128ToVector256(address); 641public static unsafe Vector256<ushort> BroadcastVector128ToVector256(ushort* address) => BroadcastVector128ToVector256(address); 649public static unsafe Vector256<int> BroadcastVector128ToVector256(int* address) => BroadcastVector128ToVector256(address); 657public static unsafe Vector256<uint> BroadcastVector128ToVector256(uint* address) => BroadcastVector128ToVector256(address); 665public static unsafe Vector256<long> BroadcastVector128ToVector256(long* address) => BroadcastVector128ToVector256(address); 673public static unsafe Vector256<ulong> BroadcastVector128ToVector256(ulong* address) => BroadcastVector128ToVector256(address); 679public static Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareEqual(left, right); 684public static Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right) => CompareEqual(left, right); 689public static Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right) => CompareEqual(left, right); 694public static Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareEqual(left, right); 699public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right) => CompareEqual(left, right); 704public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right) => CompareEqual(left, right); 709public static Vector256<long> CompareEqual(Vector256<long> left, Vector256<long> right) => CompareEqual(left, right); 714public static Vector256<ulong> CompareEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareEqual(left, right); 720public static Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right) => CompareGreaterThan(left, right); 725public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right) => CompareGreaterThan(left, right); 730public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right) => CompareGreaterThan(left, right); 735public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right) => CompareGreaterThan(left, right); 741public static int ConvertToInt32(Vector256<int> value) => ConvertToInt32(value); 746public static uint ConvertToUInt32(Vector256<uint> value) => ConvertToUInt32(value); 753public static Vector256<short> ConvertToVector256Int16(Vector128<sbyte> value) => ConvertToVector256Int16(value); 759public static Vector256<short> ConvertToVector256Int16(Vector128<byte> value) => ConvertToVector256Int16(value); 765public static Vector256<int> ConvertToVector256Int32(Vector128<sbyte> value) => ConvertToVector256Int32(value); 771public static Vector256<int> ConvertToVector256Int32(Vector128<byte> value) => ConvertToVector256Int32(value); 777public static Vector256<int> ConvertToVector256Int32(Vector128<short> value) => ConvertToVector256Int32(value); 783public static Vector256<int> ConvertToVector256Int32(Vector128<ushort> value) => ConvertToVector256Int32(value); 789public static Vector256<long> ConvertToVector256Int64(Vector128<sbyte> value) => ConvertToVector256Int64(value); 795public static Vector256<long> ConvertToVector256Int64(Vector128<byte> value) => ConvertToVector256Int64(value); 801public static Vector256<long> ConvertToVector256Int64(Vector128<short> value) => ConvertToVector256Int64(value); 807public static Vector256<long> ConvertToVector256Int64(Vector128<ushort> value) => ConvertToVector256Int64(value); 813public static Vector256<long> ConvertToVector256Int64(Vector128<int> value) => ConvertToVector256Int64(value); 819public static Vector256<long> ConvertToVector256Int64(Vector128<uint> value) => ConvertToVector256Int64(value); 826public static unsafe Vector256<short> ConvertToVector256Int16(sbyte* address) => ConvertToVector256Int16(address); 833public static unsafe Vector256<short> ConvertToVector256Int16(byte* address) => ConvertToVector256Int16(address); 840public static unsafe Vector256<int> ConvertToVector256Int32(sbyte* address) => ConvertToVector256Int32(address); 847public static unsafe Vector256<int> ConvertToVector256Int32(byte* address) => ConvertToVector256Int32(address); 854public static unsafe Vector256<int> ConvertToVector256Int32(short* address) => ConvertToVector256Int32(address); 861public static unsafe Vector256<int> ConvertToVector256Int32(ushort* address) => ConvertToVector256Int32(address); 868public static unsafe Vector256<long> ConvertToVector256Int64(sbyte* address) => ConvertToVector256Int64(address); 875public static unsafe Vector256<long> ConvertToVector256Int64(byte* address) => ConvertToVector256Int64(address); 882public static unsafe Vector256<long> ConvertToVector256Int64(short* address) => ConvertToVector256Int64(address); 889public static unsafe Vector256<long> ConvertToVector256Int64(ushort* address) => ConvertToVector256Int64(address); 896public static unsafe Vector256<long> ConvertToVector256Int64(int* address) => ConvertToVector256Int64(address); 903public static unsafe Vector256<long> ConvertToVector256Int64(uint* address) => ConvertToVector256Int64(address); 910public static new Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 916public static new Vector128<byte> ExtractVector128(Vector256<byte> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 922public static new Vector128<short> ExtractVector128(Vector256<short> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 928public static new Vector128<ushort> ExtractVector128(Vector256<ushort> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 934public static new Vector128<int> ExtractVector128(Vector256<int> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 940public static new Vector128<uint> ExtractVector128(Vector256<uint> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 946public static new Vector128<long> ExtractVector128(Vector256<long> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 952public static new Vector128<ulong> ExtractVector128(Vector256<ulong> value, [ConstantExpected] byte index) => ExtractVector128(value, index); 1163public static unsafe Vector256<int> GatherVector256(int* baseAddress, Vector256<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1180public static unsafe Vector256<uint> GatherVector256(uint* baseAddress, Vector256<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1197public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1214public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1231public static unsafe Vector256<float> GatherVector256(float* baseAddress, Vector256<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1248public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1265public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1282public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1299public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1316public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1333public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1350public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1571public static unsafe Vector256<int> GatherMaskVector256(Vector256<int> source, int* baseAddress, Vector256<int> index, Vector256<int> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1588public static unsafe Vector256<uint> GatherMaskVector256(Vector256<uint> source, uint* baseAddress, Vector256<int> index, Vector256<uint> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1605public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector128<int> index, Vector256<long> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1622public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector128<int> index, Vector256<ulong> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1639public static unsafe Vector256<float> GatherMaskVector256(Vector256<float> source, float* baseAddress, Vector256<int> index, Vector256<float> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1656public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector128<int> index, Vector256<double> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1673public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector256<long> index, Vector128<int> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1690public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector256<long> index, Vector128<uint> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1707public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector256<long> index, Vector256<long> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1724public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector256<long> index, Vector256<ulong> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1741public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector256<long> index, Vector128<float> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1758public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector256<long> index, Vector256<double> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) 1774public static Vector256<short> HorizontalAdd(Vector256<short> left, Vector256<short> right) => HorizontalAdd(left, right); 1779public static Vector256<int> HorizontalAdd(Vector256<int> left, Vector256<int> right) => HorizontalAdd(left, right); 1785public static Vector256<short> HorizontalAddSaturate(Vector256<short> left, Vector256<short> right) => HorizontalAddSaturate(left, right); 1791public static Vector256<short> HorizontalSubtract(Vector256<short> left, Vector256<short> right) => HorizontalSubtract(left, right); 1796public static Vector256<int> HorizontalSubtract(Vector256<int> left, Vector256<int> right) => HorizontalSubtract(left, right); 1802public static Vector256<short> HorizontalSubtractSaturate(Vector256<short> left, Vector256<short> right) => HorizontalSubtractSaturate(left, right); 1809public static new Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 1815public static new Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 1821public static new Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 1827public static new Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 1833public static new Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 1839public static new Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 1845public static new Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 1851public static new Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, [ConstantExpected] byte index) => InsertVector128(value, data, index); 1857public static unsafe Vector256<sbyte> LoadAlignedVector256NonTemporal(sbyte* address) => LoadAlignedVector256NonTemporal(address); 1863public static unsafe Vector256<byte> LoadAlignedVector256NonTemporal(byte* address) => LoadAlignedVector256NonTemporal(address); 1869public static unsafe Vector256<short> LoadAlignedVector256NonTemporal(short* address) => LoadAlignedVector256NonTemporal(address); 1875public static unsafe Vector256<ushort> LoadAlignedVector256NonTemporal(ushort* address) => LoadAlignedVector256NonTemporal(address); 1881public static unsafe Vector256<int> LoadAlignedVector256NonTemporal(int* address) => LoadAlignedVector256NonTemporal(address); 1887public static unsafe Vector256<uint> LoadAlignedVector256NonTemporal(uint* address) => LoadAlignedVector256NonTemporal(address); 1893public static unsafe Vector256<long> LoadAlignedVector256NonTemporal(long* address) => LoadAlignedVector256NonTemporal(address); 1899public static unsafe Vector256<ulong> LoadAlignedVector256NonTemporal(ulong* address) => LoadAlignedVector256NonTemporal(address); 1929public static unsafe Vector256<int> MaskLoad(int* address, Vector256<int> mask) => MaskLoad(address, mask); 1935public static unsafe Vector256<uint> MaskLoad(uint* address, Vector256<uint> mask) => MaskLoad(address, mask); 1941public static unsafe Vector256<long> MaskLoad(long* address, Vector256<long> mask) => MaskLoad(address, mask); 1947public static unsafe Vector256<ulong> MaskLoad(ulong* address, Vector256<ulong> mask) => MaskLoad(address, mask); 1977public static unsafe void MaskStore(int* address, Vector256<int> mask, Vector256<int> source) => MaskStore(address, mask, source); 1983public static unsafe void MaskStore(uint* address, Vector256<uint> mask, Vector256<uint> source) => MaskStore(address, mask, source); 1989public static unsafe void MaskStore(long* address, Vector256<long> mask, Vector256<long> source) => MaskStore(address, mask, source); 1995public static unsafe void MaskStore(ulong* address, Vector256<ulong> mask, Vector256<ulong> source) => MaskStore(address, mask, source); 2002public static Vector256<int> MultiplyAddAdjacent(Vector256<short> left, Vector256<short> right) => MultiplyAddAdjacent(left, right); 2008public static Vector256<short> MultiplyAddAdjacent(Vector256<byte> left, Vector256<sbyte> right) => MultiplyAddAdjacent(left, right); 2015public static Vector256<sbyte> Max(Vector256<sbyte> left, Vector256<sbyte> right) => Max(left, right); 2021public static Vector256<byte> Max(Vector256<byte> left, Vector256<byte> right) => Max(left, right); 2027public static Vector256<short> Max(Vector256<short> left, Vector256<short> right) => Max(left, right); 2033public static Vector256<ushort> Max(Vector256<ushort> left, Vector256<ushort> right) => Max(left, right); 2039public static Vector256<int> Max(Vector256<int> left, Vector256<int> right) => Max(left, right); 2045public static Vector256<uint> Max(Vector256<uint> left, Vector256<uint> right) => Max(left, right); 2052public static Vector256<sbyte> Min(Vector256<sbyte> left, Vector256<sbyte> right) => Min(left, right); 2058public static Vector256<byte> Min(Vector256<byte> left, Vector256<byte> right) => Min(left, right); 2064public static Vector256<short> Min(Vector256<short> left, Vector256<short> right) => Min(left, right); 2070public static Vector256<ushort> Min(Vector256<ushort> left, Vector256<ushort> right) => Min(left, right); 2076public static Vector256<int> Min(Vector256<int> left, Vector256<int> right) => Min(left, right); 2082public static Vector256<uint> Min(Vector256<uint> left, Vector256<uint> right) => Min(left, right); 2088public static int MoveMask(Vector256<sbyte> value) => MoveMask(value); 2093public static int MoveMask(Vector256<byte> value) => MoveMask(value); 2099public static Vector256<ushort> MultipleSumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte mask) => MultipleSumAbsoluteDifferences(left, right, mask); 2106public static Vector256<long> Multiply(Vector256<int> left, Vector256<int> right) => Multiply(left, right); 2112public static Vector256<ulong> Multiply(Vector256<uint> left, Vector256<uint> right) => Multiply(left, right); 2119public static Vector256<short> MultiplyHigh(Vector256<short> left, Vector256<short> right) => MultiplyHigh(left, right); 2125public static Vector256<ushort> MultiplyHigh(Vector256<ushort> left, Vector256<ushort> right) => MultiplyHigh(left, right); 2132public static Vector256<short> MultiplyHighRoundScale(Vector256<short> left, Vector256<short> right) => MultiplyHighRoundScale(left, right); 2139public static Vector256<short> MultiplyLow(Vector256<short> left, Vector256<short> right) => MultiplyLow(left, right); 2145public static Vector256<ushort> MultiplyLow(Vector256<ushort> left, Vector256<ushort> right) => MultiplyLow(left, right); 2151public static Vector256<int> MultiplyLow(Vector256<int> left, Vector256<int> right) => MultiplyLow(left, right); 2157public static Vector256<uint> MultiplyLow(Vector256<uint> left, Vector256<uint> right) => MultiplyLow(left, right); 2163public static Vector256<sbyte> Or(Vector256<sbyte> left, Vector256<sbyte> right) => Or(left, right); 2168public static Vector256<byte> Or(Vector256<byte> left, Vector256<byte> right) => Or(left, right); 2173public static Vector256<short> Or(Vector256<short> left, Vector256<short> right) => Or(left, right); 2178public static Vector256<ushort> Or(Vector256<ushort> left, Vector256<ushort> right) => Or(left, right); 2184public static Vector256<int> Or(Vector256<int> left, Vector256<int> right) => Or(left, right); 2190public static Vector256<uint> Or(Vector256<uint> left, Vector256<uint> right) => Or(left, right); 2196public static Vector256<long> Or(Vector256<long> left, Vector256<long> right) => Or(left, right); 2202public static Vector256<ulong> Or(Vector256<ulong> left, Vector256<ulong> right) => Or(left, right); 2209public static Vector256<sbyte> PackSignedSaturate(Vector256<short> left, Vector256<short> right) => PackSignedSaturate(left, right); 2215public static Vector256<short> PackSignedSaturate(Vector256<int> left, Vector256<int> right) => PackSignedSaturate(left, right); 2222public static Vector256<byte> PackUnsignedSaturate(Vector256<short> left, Vector256<short> right) => PackUnsignedSaturate(left, right); 2228public static Vector256<ushort> PackUnsignedSaturate(Vector256<int> left, Vector256<int> right) => PackUnsignedSaturate(left, right); 2234public static new Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 2239public static new Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 2244public static new Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 2249public static new Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 2254public static new Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 2259public static new Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 2264public static new Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 2269public static new Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte control) => Permute2x128(left, right, control); 2276public static Vector256<long> Permute4x64(Vector256<long> value, [ConstantExpected] byte control) => Permute4x64(value, control); 2282public static Vector256<ulong> Permute4x64(Vector256<ulong> value, [ConstantExpected] byte control) => Permute4x64(value, control); 2288public static Vector256<double> Permute4x64(Vector256<double> value, [ConstantExpected] byte control) => Permute4x64(value, control); 2295public static Vector256<int> PermuteVar8x32(Vector256<int> left, Vector256<int> control) => PermuteVar8x32(left, control); 2301public static Vector256<uint> PermuteVar8x32(Vector256<uint> left, Vector256<uint> control) => PermuteVar8x32(left, control); 2307public static Vector256<float> PermuteVar8x32(Vector256<float> left, Vector256<int> control) => PermuteVar8x32(left, control); 2314public static Vector256<short> ShiftLeftLogical(Vector256<short> value, Vector128<short> count) => ShiftLeftLogical(value, count); 2320public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, Vector128<ushort> count) => ShiftLeftLogical(value, count); 2326public static Vector256<int> ShiftLeftLogical(Vector256<int> value, Vector128<int> count) => ShiftLeftLogical(value, count); 2332public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, Vector128<uint> count) => ShiftLeftLogical(value, count); 2338public static Vector256<long> ShiftLeftLogical(Vector256<long> value, Vector128<long> count) => ShiftLeftLogical(value, count); 2344public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, Vector128<ulong> count) => ShiftLeftLogical(value, count); 2351public static Vector256<short> ShiftLeftLogical(Vector256<short> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); 2357public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); 2363public static Vector256<int> ShiftLeftLogical(Vector256<int> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); 2369public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); 2375public static Vector256<long> ShiftLeftLogical(Vector256<long> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); 2381public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); 2387public static Vector256<sbyte> ShiftLeftLogical128BitLane(Vector256<sbyte> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); 2392public static Vector256<byte> ShiftLeftLogical128BitLane(Vector256<byte> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); 2398public static Vector256<short> ShiftLeftLogical128BitLane(Vector256<short> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); 2404public static Vector256<ushort> ShiftLeftLogical128BitLane(Vector256<ushort> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); 2410public static Vector256<int> ShiftLeftLogical128BitLane(Vector256<int> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); 2416public static Vector256<uint> ShiftLeftLogical128BitLane(Vector256<uint> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); 2422public static Vector256<long> ShiftLeftLogical128BitLane(Vector256<long> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); 2428public static Vector256<ulong> ShiftLeftLogical128BitLane(Vector256<ulong> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); 2459public static Vector256<int> ShiftLeftLogicalVariable(Vector256<int> value, Vector256<uint> count) => ShiftLeftLogicalVariable(value, count); 2465public static Vector256<uint> ShiftLeftLogicalVariable(Vector256<uint> value, Vector256<uint> count) => ShiftLeftLogicalVariable(value, count); 2471public static Vector256<long> ShiftLeftLogicalVariable(Vector256<long> value, Vector256<ulong> count) => ShiftLeftLogicalVariable(value, count); 2477public static Vector256<ulong> ShiftLeftLogicalVariable(Vector256<ulong> value, Vector256<ulong> count) => ShiftLeftLogicalVariable(value, count); 2484public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, Vector128<short> count) => ShiftRightArithmetic(value, count); 2490public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, Vector128<int> count) => ShiftRightArithmetic(value, count); 2497public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); 2503public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); 2516public static Vector256<int> ShiftRightArithmeticVariable(Vector256<int> value, Vector256<uint> count) => ShiftRightArithmeticVariable(value, count); 2523public static Vector256<short> ShiftRightLogical(Vector256<short> value, Vector128<short> count) => ShiftRightLogical(value, count); 2529public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, Vector128<ushort> count) => ShiftRightLogical(value, count); 2535public static Vector256<int> ShiftRightLogical(Vector256<int> value, Vector128<int> count) => ShiftRightLogical(value, count); 2541public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, Vector128<uint> count) => ShiftRightLogical(value, count); 2547public static Vector256<long> ShiftRightLogical(Vector256<long> value, Vector128<long> count) => ShiftRightLogical(value, count); 2553public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, Vector128<ulong> count) => ShiftRightLogical(value, count); 2560public static Vector256<short> ShiftRightLogical(Vector256<short> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); 2566public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); 2572public static Vector256<int> ShiftRightLogical(Vector256<int> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); 2578public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); 2584public static Vector256<long> ShiftRightLogical(Vector256<long> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); 2590public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); 2596public static Vector256<sbyte> ShiftRightLogical128BitLane(Vector256<sbyte> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); 2601public static Vector256<byte> ShiftRightLogical128BitLane(Vector256<byte> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); 2607public static Vector256<short> ShiftRightLogical128BitLane(Vector256<short> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); 2613public static Vector256<ushort> ShiftRightLogical128BitLane(Vector256<ushort> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); 2619public static Vector256<int> ShiftRightLogical128BitLane(Vector256<int> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); 2625public static Vector256<uint> ShiftRightLogical128BitLane(Vector256<uint> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); 2631public static Vector256<long> ShiftRightLogical128BitLane(Vector256<long> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); 2637public static Vector256<ulong> ShiftRightLogical128BitLane(Vector256<ulong> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); 2668public static Vector256<int> ShiftRightLogicalVariable(Vector256<int> value, Vector256<uint> count) => ShiftRightLogicalVariable(value, count); 2674public static Vector256<uint> ShiftRightLogicalVariable(Vector256<uint> value, Vector256<uint> count) => ShiftRightLogicalVariable(value, count); 2680public static Vector256<long> ShiftRightLogicalVariable(Vector256<long> value, Vector256<ulong> count) => ShiftRightLogicalVariable(value, count); 2686public static Vector256<ulong> ShiftRightLogicalVariable(Vector256<ulong> value, Vector256<ulong> count) => ShiftRightLogicalVariable(value, count); 2693public static Vector256<sbyte> Shuffle(Vector256<sbyte> value, Vector256<sbyte> mask) => Shuffle(value, mask); 2699public static Vector256<byte> Shuffle(Vector256<byte> value, Vector256<byte> mask) => Shuffle(value, mask); 2705public static Vector256<int> Shuffle(Vector256<int> value, [ConstantExpected] byte control) => Shuffle(value, control); 2711public static Vector256<uint> Shuffle(Vector256<uint> value, [ConstantExpected] byte control) => Shuffle(value, control); 2718public static Vector256<short> ShuffleHigh(Vector256<short> value, [ConstantExpected] byte control) => ShuffleHigh(value, control); 2724public static Vector256<ushort> ShuffleHigh(Vector256<ushort> value, [ConstantExpected] byte control) => ShuffleHigh(value, control); 2731public static Vector256<short> ShuffleLow(Vector256<short> value, [ConstantExpected] byte control) => ShuffleLow(value, control); 2737public static Vector256<ushort> ShuffleLow(Vector256<ushort> value, [ConstantExpected] byte control) => ShuffleLow(value, control); 2743public static Vector256<sbyte> Sign(Vector256<sbyte> left, Vector256<sbyte> right) => Sign(left, right); 2748public static Vector256<short> Sign(Vector256<short> left, Vector256<short> right) => Sign(left, right); 2753public static Vector256<int> Sign(Vector256<int> left, Vector256<int> right) => Sign(left, right); 2760public static Vector256<sbyte> Subtract(Vector256<sbyte> left, Vector256<sbyte> right) => Subtract(left, right); 2766public static Vector256<byte> Subtract(Vector256<byte> left, Vector256<byte> right) => Subtract(left, right); 2772public static Vector256<short> Subtract(Vector256<short> left, Vector256<short> right) => Subtract(left, right); 2778public static Vector256<ushort> Subtract(Vector256<ushort> left, Vector256<ushort> right) => Subtract(left, right); 2784public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right) => Subtract(left, right); 2790public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right) => Subtract(left, right); 2796public static Vector256<long> Subtract(Vector256<long> left, Vector256<long> right) => Subtract(left, right); 2802public static Vector256<ulong> Subtract(Vector256<ulong> left, Vector256<ulong> right) => Subtract(left, right); 2809public static Vector256<sbyte> SubtractSaturate(Vector256<sbyte> left, Vector256<sbyte> right) => SubtractSaturate(left, right); 2815public static Vector256<short> SubtractSaturate(Vector256<short> left, Vector256<short> right) => SubtractSaturate(left, right); 2821public static Vector256<byte> SubtractSaturate(Vector256<byte> left, Vector256<byte> right) => SubtractSaturate(left, right); 2827public static Vector256<ushort> SubtractSaturate(Vector256<ushort> left, Vector256<ushort> right) => SubtractSaturate(left, right); 2834public static Vector256<ushort> SumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right) => SumAbsoluteDifferences(left, right); 2841public static Vector256<sbyte> UnpackHigh(Vector256<sbyte> left, Vector256<sbyte> right) => UnpackHigh(left, right); 2847public static Vector256<byte> UnpackHigh(Vector256<byte> left, Vector256<byte> right) => UnpackHigh(left, right); 2853public static Vector256<short> UnpackHigh(Vector256<short> left, Vector256<short> right) => UnpackHigh(left, right); 2859public static Vector256<ushort> UnpackHigh(Vector256<ushort> left, Vector256<ushort> right) => UnpackHigh(left, right); 2865public static Vector256<int> UnpackHigh(Vector256<int> left, Vector256<int> right) => UnpackHigh(left, right); 2871public static Vector256<uint> UnpackHigh(Vector256<uint> left, Vector256<uint> right) => UnpackHigh(left, right); 2877public static Vector256<long> UnpackHigh(Vector256<long> left, Vector256<long> right) => UnpackHigh(left, right); 2883public static Vector256<ulong> UnpackHigh(Vector256<ulong> left, Vector256<ulong> right) => UnpackHigh(left, right); 2890public static Vector256<sbyte> UnpackLow(Vector256<sbyte> left, Vector256<sbyte> right) => UnpackLow(left, right); 2896public static Vector256<byte> UnpackLow(Vector256<byte> left, Vector256<byte> right) => UnpackLow(left, right); 2902public static Vector256<short> UnpackLow(Vector256<short> left, Vector256<short> right) => UnpackLow(left, right); 2908public static Vector256<ushort> UnpackLow(Vector256<ushort> left, Vector256<ushort> right) => UnpackLow(left, right); 2914public static Vector256<int> UnpackLow(Vector256<int> left, Vector256<int> right) => UnpackLow(left, right); 2920public static Vector256<uint> UnpackLow(Vector256<uint> left, Vector256<uint> right) => UnpackLow(left, right); 2926public static Vector256<long> UnpackLow(Vector256<long> left, Vector256<long> right) => UnpackLow(left, right); 2932public static Vector256<ulong> UnpackLow(Vector256<ulong> left, Vector256<ulong> right) => UnpackLow(left, right); 2938public static Vector256<sbyte> Xor(Vector256<sbyte> left, Vector256<sbyte> right) => Xor(left, right); 2943public static Vector256<byte> Xor(Vector256<byte> left, Vector256<byte> right) => Xor(left, right); 2948public static Vector256<short> Xor(Vector256<short> left, Vector256<short> right) => Xor(left, right); 2953public static Vector256<ushort> Xor(Vector256<ushort> left, Vector256<ushort> right) => Xor(left, right); 2959public static Vector256<int> Xor(Vector256<int> left, Vector256<int> right) => Xor(left, right); 2965public static Vector256<uint> Xor(Vector256<uint> left, Vector256<uint> right) => Xor(left, right); 2971public static Vector256<long> Xor(Vector256<long> left, Vector256<long> right) => Xor(left, right); 2977public static Vector256<ulong> Xor(Vector256<ulong> left, Vector256<ulong> right) => Xor(left, right);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Avx512Bmm.cs (10)
30public static Vector256<byte> ReverseBits(Vector256<byte> values) => ReverseBits(values); 42public static Vector256<ushort> BitMultiplyMatrix16x16WithOrReduction(Vector256<ushort> addend, Vector256<ushort> left, Vector256<ushort> right) => BitMultiplyMatrix16x16WithOrReduction(addend, left, right); 54public static Vector256<ushort> BitMultiplyMatrix16x16WithXorReduction(Vector256<ushort> addend, Vector256<ushort> left, Vector256<ushort> right) => BitMultiplyMatrix16x16WithXorReduction(addend, left, right);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Avx512BW.cs (158)
62public static Vector256<byte> BlendVariable(Vector256<byte> left, Vector256<byte> right, Vector256<byte> mask) => BlendVariable(left, right, mask); 68public static Vector256<short> BlendVariable(Vector256<short> left, Vector256<short> right, Vector256<short> mask) => BlendVariable(left, right, mask); 74public static Vector256<sbyte> BlendVariable(Vector256<sbyte> left, Vector256<sbyte> right, Vector256<sbyte> mask) => BlendVariable(left, right, mask); 80public static Vector256<ushort> BlendVariable(Vector256<ushort> left, Vector256<ushort> right, Vector256<ushort> mask) => BlendVariable(left, right, mask); 117public static Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right) => CompareEqual(left, right); 122public static Vector256<byte> CompareGreaterThan(Vector256<byte> left, Vector256<byte> right) => CompareGreaterThan(left, right); 127public static Vector256<byte> CompareGreaterThanOrEqual(Vector256<byte> left, Vector256<byte> right) => CompareGreaterThanOrEqual(left, right); 132public static Vector256<byte> CompareLessThan(Vector256<byte> left, Vector256<byte> right) => CompareLessThan(left, right); 137public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> left, Vector256<byte> right) => CompareLessThanOrEqual(left, right); 142public static Vector256<byte> CompareNotEqual(Vector256<byte> left, Vector256<byte> right) => CompareNotEqual(left, right); 179public static Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right) => CompareEqual(left, right); 184public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right) => CompareGreaterThan(left, right); 189public static Vector256<short> CompareGreaterThanOrEqual(Vector256<short> left, Vector256<short> right) => CompareGreaterThanOrEqual(left, right); 194public static Vector256<short> CompareLessThan(Vector256<short> left, Vector256<short> right) => CompareLessThan(left, right); 199public static Vector256<short> CompareLessThanOrEqual(Vector256<short> left, Vector256<short> right) => CompareLessThanOrEqual(left, right); 204public static Vector256<short> CompareNotEqual(Vector256<short> left, Vector256<short> right) => CompareNotEqual(left, right); 241public static Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareEqual(left, right); 246public static Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right) => CompareGreaterThan(left, right); 251public static Vector256<sbyte> CompareGreaterThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareGreaterThanOrEqual(left, right); 256public static Vector256<sbyte> CompareLessThan(Vector256<sbyte> left, Vector256<sbyte> right) => CompareLessThan(left, right); 261public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareLessThanOrEqual(left, right); 266public static Vector256<sbyte> CompareNotEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareNotEqual(left, right); 303public static Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareEqual(left, right); 308public static Vector256<ushort> CompareGreaterThan(Vector256<ushort> left, Vector256<ushort> right) => CompareGreaterThan(left, right); 313public static Vector256<ushort> CompareGreaterThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareGreaterThanOrEqual(left, right); 318public static Vector256<ushort> CompareLessThan(Vector256<ushort> left, Vector256<ushort> right) => CompareLessThan(left, right); 323public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareLessThanOrEqual(left, right); 328public static Vector256<ushort> CompareNotEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareNotEqual(left, right); 344public static Vector128<byte> ConvertToVector128Byte(Vector256<short> value) => ConvertToVector128Byte(value); 349public static Vector128<byte> ConvertToVector128Byte(Vector256<ushort> value) => ConvertToVector128Byte(value); 359public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<ushort> value) => ConvertToVector128ByteWithSaturation(value); 375public static Vector128<sbyte> ConvertToVector128SByte(Vector256<short> value) => ConvertToVector128SByte(value); 380public static Vector128<sbyte> ConvertToVector128SByte(Vector256<ushort> value) => ConvertToVector128SByte(value); 390public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<short> value) => ConvertToVector128SByteWithSaturation(value); 425public static unsafe Vector256<byte> MaskLoad(byte* address, Vector256<byte> mask, Vector256<byte> merge) => MaskLoad(address, mask, merge); 432public static unsafe Vector256<short> MaskLoad(short* address, Vector256<short> mask, Vector256<short> merge) => MaskLoad(address, mask, merge); 439public static unsafe Vector256<sbyte> MaskLoad(sbyte* address, Vector256<sbyte> mask, Vector256<sbyte> merge) => MaskLoad(address, mask, merge); 446public static unsafe Vector256<ushort> MaskLoad(ushort* address, Vector256<ushort> mask, Vector256<ushort> merge) => MaskLoad(address, mask, merge); 476public static unsafe void MaskStore(byte* address, Vector256<byte> mask, Vector256<byte> source) => MaskStore(address, mask, source); 482public static unsafe void MaskStore(short* address, Vector256<short> mask, Vector256<short> source) => MaskStore(address, mask, source); 488public static unsafe void MaskStore(sbyte* address, Vector256<sbyte> mask, Vector256<sbyte> source) => MaskStore(address, mask, source); 494public static unsafe void MaskStore(ushort* address, Vector256<ushort> mask, Vector256<ushort> source) => MaskStore(address, mask, source); 527public static Vector256<short> PermuteVar16x16(Vector256<short> left, Vector256<short> control) => PermuteVar16x16(left, control); 533public static Vector256<ushort> PermuteVar16x16(Vector256<ushort> left, Vector256<ushort> control) => PermuteVar16x16(left, control); 540public static Vector256<short> PermuteVar16x16x2(Vector256<short> lower, Vector256<short> indices, Vector256<short> upper) => PermuteVar16x16x2(lower, indices, upper); 546public static Vector256<ushort> PermuteVar16x16x2(Vector256<ushort> lower, Vector256<ushort> indices, Vector256<ushort> upper) => PermuteVar16x16x2(lower, indices, upper); 562public static Vector256<short> ShiftLeftLogicalVariable(Vector256<short> value, Vector256<ushort> count) => ShiftLeftLogicalVariable(value, count); 567public static Vector256<ushort> ShiftLeftLogicalVariable(Vector256<ushort> value, Vector256<ushort> count) => ShiftLeftLogicalVariable(value, count); 578public static Vector256<short> ShiftRightArithmeticVariable(Vector256<short> value, Vector256<ushort> count) => ShiftRightArithmeticVariable(value, count); 594public static Vector256<short> ShiftRightLogicalVariable(Vector256<short> value, Vector256<ushort> count) => ShiftRightLogicalVariable(value, count); 599public static Vector256<ushort> ShiftRightLogicalVariable(Vector256<ushort> value, Vector256<ushort> count) => ShiftRightLogicalVariable(value, count); 610public static Vector256<ushort> SumAbsoluteDifferencesInBlock32(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte control) => SumAbsoluteDifferencesInBlock32(left, right, control); 874public static Vector256<byte> ConvertToVector256Byte(Vector512<short> value) => ConvertToVector256Byte(value); 879public static Vector256<byte> ConvertToVector256Byte(Vector512<ushort> value) => ConvertToVector256Byte(value); 884public static Vector256<byte> ConvertToVector256ByteWithSaturation(Vector512<ushort> value) => ConvertToVector256ByteWithSaturation(value); 890public static Vector256<sbyte> ConvertToVector256SByte(Vector512<short> value) => ConvertToVector256SByte(value); 895public static Vector256<sbyte> ConvertToVector256SByte(Vector512<ushort> value) => ConvertToVector256SByte(value); 900public static Vector256<sbyte> ConvertToVector256SByteWithSaturation(Vector512<short> value) => ConvertToVector256SByteWithSaturation(value); 906public static Vector512<short> ConvertToVector512Int16(Vector256<sbyte> value) => ConvertToVector512Int16(value); 911public static Vector512<short> ConvertToVector512Int16(Vector256<byte> value) => ConvertToVector512Int16(value); 916public static Vector512<ushort> ConvertToVector512UInt16(Vector256<sbyte> value) => ConvertToVector512UInt16(value); 921public static Vector512<ushort> ConvertToVector512UInt16(Vector256<byte> value) => ConvertToVector512UInt16(value); 1045public static new int MoveMask(Vector256<byte> value) => MoveMask(value); 1050public static new int MoveMask(Vector256<sbyte> value) => MoveMask(value);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Avx512CD.cs (16)
56public static Vector256<int> DetectConflicts(Vector256<int> value) => DetectConflicts(value); 61public static Vector256<uint> DetectConflicts(Vector256<uint> value) => DetectConflicts(value); 66public static Vector256<long> DetectConflicts(Vector256<long> value) => DetectConflicts(value); 71public static Vector256<ulong> DetectConflicts(Vector256<ulong> value) => DetectConflicts(value); 97public static Vector256<int> LeadingZeroCount(Vector256<int> value) => LeadingZeroCount(value); 102public static Vector256<uint> LeadingZeroCount(Vector256<uint> value) => LeadingZeroCount(value); 107public static Vector256<long> LeadingZeroCount(Vector256<long> value) => LeadingZeroCount(value); 112public static Vector256<ulong> LeadingZeroCount(Vector256<ulong> value) => LeadingZeroCount(value);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Avx512DQ.cs (63)
47public static Vector256<int> BroadcastPairScalarToVector256(Vector128<int> value) => BroadcastPairScalarToVector256(value); 52public static Vector256<uint> BroadcastPairScalarToVector256(Vector128<uint> value) => BroadcastPairScalarToVector256(value); 57public static Vector256<float> BroadcastPairScalarToVector256(Vector128<float> value) => BroadcastPairScalarToVector256(value); 73public static Vector256<double> Classify(Vector256<double> value, [ConstantExpected] byte control) => Classify(value, control); 78public static Vector256<float> Classify(Vector256<float> value, [ConstantExpected] byte control) => Classify(value, control); 119public static Vector128<float> ConvertToVector128Single(Vector256<long> value) => ConvertToVector128Single(value); 129public static Vector128<float> ConvertToVector128Single(Vector256<ulong> value) => ConvertToVector128Single(value); 155public static Vector256<double> ConvertToVector256Double(Vector256<long> value) => ConvertToVector256Double(value); 160public static Vector256<double> ConvertToVector256Double(Vector256<ulong> value) => ConvertToVector256Double(value); 165public static Vector256<long> ConvertToVector256Int64(Vector128<float> value) => ConvertToVector256Int64(value); 170public static Vector256<long> ConvertToVector256Int64(Vector256<double> value) => ConvertToVector256Int64(value); 175public static Vector256<long> ConvertToVector256Int64WithTruncation(Vector128<float> value) => ConvertToVector256Int64WithTruncation(value); 180public static Vector256<long> ConvertToVector256Int64WithTruncation(Vector256<double> value) => ConvertToVector256Int64WithTruncation(value); 185public static Vector256<ulong> ConvertToVector256UInt64(Vector128<float> value) => ConvertToVector256UInt64(value); 190public static Vector256<ulong> ConvertToVector256UInt64(Vector256<double> value) => ConvertToVector256UInt64(value); 195public static Vector256<ulong> ConvertToVector256UInt64WithTruncation(Vector128<float> value) => ConvertToVector256UInt64WithTruncation(value); 200public static Vector256<ulong> ConvertToVector256UInt64WithTruncation(Vector256<double> value) => ConvertToVector256UInt64WithTruncation(value); 216public static Vector256<long> MultiplyLow(Vector256<long> left, Vector256<long> right) => MultiplyLow(left, right); 221public static Vector256<ulong> MultiplyLow(Vector256<ulong> left, Vector256<ulong> right) => MultiplyLow(left, right); 237public static Vector256<float> Range(Vector256<float> left, Vector256<float> right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); 242public static Vector256<double> Range(Vector256<double> left, Vector256<double> right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); 258public static Vector256<float> Reduce(Vector256<float> value, [ConstantExpected] byte control) => Reduce(value, control); 263public static Vector256<double> Reduce(Vector256<double> value, [ConstantExpected] byte control) => Reduce(value, control); 378public static Vector256<float> ConvertToVector256Single(Vector512<long> value) => ConvertToVector256Single(value); 383public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value) => ConvertToVector256Single(value); 388public static Vector256<float> ConvertToVector256Single(Vector512<long> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); 393public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); 420public static Vector512<long> ConvertToVector512Int64(Vector256<float> value) => ConvertToVector512Int64(value); 430public static Vector512<long> ConvertToVector512Int64(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int64(value, mode); 441public static Vector512<long> ConvertToVector512Int64WithTruncation(Vector256<float> value) => ConvertToVector512Int64WithTruncation(value); 451public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value) => ConvertToVector512UInt64(value); 461public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt64(value, mode); 471public static Vector512<ulong> ConvertToVector512UInt64WithTruncation(Vector256<float> value) => ConvertToVector512UInt64WithTruncation(value); 498public static new Vector256<int> ExtractVector256(Vector512<int> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 503public static new Vector256<uint> ExtractVector256(Vector512<uint> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 508public static new Vector256<float> ExtractVector256(Vector512<float> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 530public static new Vector512<int> InsertVector256(Vector512<int> value, Vector256<int> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 535public static new Vector512<uint> InsertVector256(Vector512<uint> value, Vector256<uint> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 540public static new Vector512<float> InsertVector256(Vector512<float> value, Vector256<float> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 588public static new int MoveMask(Vector256<double> value) => MoveMask(value); 593public static int MoveMask(Vector256<int> value) => MoveMask(value); 598public static int MoveMask(Vector256<long> value) => MoveMask(value); 603public static new int MoveMask(Vector256<float> value) => MoveMask(value); 608public static int MoveMask(Vector256<uint> value) => MoveMask(value); 613public static int MoveMask(Vector256<ulong> value) => MoveMask(value);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Avx512F.cs (602)
41public static Vector256<ulong> Abs(Vector256<long> value) => Abs(value); 57public static Vector256<int> AlignRight32(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); 62public static Vector256<uint> AlignRight32(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); 78public static Vector256<long> AlignRight64(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); 83public static Vector256<ulong> AlignRight64(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); 127public static Vector256<double> BlendVariable(Vector256<double> left, Vector256<double> right, Vector256<double> mask) => BlendVariable(left, right, mask); 133public static Vector256<int> BlendVariable(Vector256<int> left, Vector256<int> right, Vector256<int> mask) => BlendVariable(left, right, mask); 139public static Vector256<long> BlendVariable(Vector256<long> left, Vector256<long> right, Vector256<long> mask) => BlendVariable(left, right, mask); 145public static Vector256<float> BlendVariable(Vector256<float> left, Vector256<float> right, Vector256<float> mask) => BlendVariable(left, right, mask); 151public static Vector256<uint> BlendVariable(Vector256<uint> left, Vector256<uint> right, Vector256<uint> mask) => BlendVariable(left, right, mask); 157public static Vector256<ulong> BlendVariable(Vector256<ulong> left, Vector256<ulong> right, Vector256<ulong> mask) => BlendVariable(left, right, mask); 241public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode); 247public static Vector256<double> CompareEqual(Vector256<double> left, Vector256<double> right) => CompareEqual(left, right); 253public static Vector256<double> CompareGreaterThan(Vector256<double> left, Vector256<double> right) => CompareGreaterThan(left, right); 259public static Vector256<double> CompareGreaterThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareGreaterThanOrEqual(left, right); 265public static Vector256<double> CompareLessThan(Vector256<double> left, Vector256<double> right) => CompareLessThan(left, right); 271public static Vector256<double> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareLessThanOrEqual(left, right); 277public static Vector256<double> CompareNotEqual(Vector256<double> left, Vector256<double> right) => CompareNotEqual(left, right); 283public static Vector256<double> CompareNotGreaterThan(Vector256<double> left, Vector256<double> right) => CompareNotGreaterThan(left, right); 289public static Vector256<double> CompareNotGreaterThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareNotGreaterThanOrEqual(left, right); 295public static Vector256<double> CompareNotLessThan(Vector256<double> left, Vector256<double> right) => CompareNotLessThan(left, right); 301public static Vector256<double> CompareNotLessThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareNotLessThanOrEqual(left, right); 307public static Vector256<double> CompareOrdered(Vector256<double> left, Vector256<double> right) => CompareOrdered(left, right); 313public static Vector256<double> CompareUnordered(Vector256<double> left, Vector256<double> right) => CompareUnordered(left, right); 350public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right) => CompareEqual(left, right); 355public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right) => CompareGreaterThan(left, right); 360public static Vector256<int> CompareGreaterThanOrEqual(Vector256<int> left, Vector256<int> right) => CompareGreaterThanOrEqual(left, right); 365public static Vector256<int> CompareLessThan(Vector256<int> left, Vector256<int> right) => CompareLessThan(left, right); 370public static Vector256<int> CompareLessThanOrEqual(Vector256<int> left, Vector256<int> right) => CompareLessThanOrEqual(left, right); 375public static Vector256<int> CompareNotEqual(Vector256<int> left, Vector256<int> right) => CompareNotEqual(left, right); 412public static Vector256<long> CompareEqual(Vector256<long> left, Vector256<long> right) => CompareEqual(left, right); 417public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right) => CompareGreaterThan(left, right); 422public static Vector256<long> CompareGreaterThanOrEqual(Vector256<long> left, Vector256<long> right) => CompareGreaterThanOrEqual(left, right); 427public static Vector256<long> CompareLessThan(Vector256<long> left, Vector256<long> right) => CompareLessThan(left, right); 432public static Vector256<long> CompareLessThanOrEqual(Vector256<long> left, Vector256<long> right) => CompareLessThanOrEqual(left, right); 437public static Vector256<long> CompareNotEqual(Vector256<long> left, Vector256<long> right) => CompareNotEqual(left, right); 521public static Vector256<float> Compare(Vector256<float> left, Vector256<float> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode); 527public static Vector256<float> CompareEqual(Vector256<float> left, Vector256<float> right) => CompareEqual(left, right); 533public static Vector256<float> CompareGreaterThan(Vector256<float> left, Vector256<float> right) => CompareGreaterThan(left, right); 539public static Vector256<float> CompareGreaterThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareGreaterThanOrEqual(left, right); 545public static Vector256<float> CompareLessThan(Vector256<float> left, Vector256<float> right) => CompareLessThan(left, right); 551public static Vector256<float> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareLessThanOrEqual(left, right); 557public static Vector256<float> CompareNotEqual(Vector256<float> left, Vector256<float> right) => CompareNotEqual(left, right); 563public static Vector256<float> CompareNotGreaterThan(Vector256<float> left, Vector256<float> right) => CompareNotGreaterThan(left, right); 569public static Vector256<float> CompareNotGreaterThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareNotGreaterThanOrEqual(left, right); 575public static Vector256<float> CompareNotLessThan(Vector256<float> left, Vector256<float> right) => CompareNotLessThan(left, right); 581public static Vector256<float> CompareNotLessThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareNotLessThanOrEqual(left, right); 587public static Vector256<float> CompareOrdered(Vector256<float> left, Vector256<float> right) => CompareOrdered(left, right); 593public static Vector256<float> CompareUnordered(Vector256<float> left, Vector256<float> right) => CompareUnordered(left, right); 630public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right) => CompareEqual(left, right); 635public static Vector256<uint> CompareGreaterThan(Vector256<uint> left, Vector256<uint> right) => CompareGreaterThan(left, right); 640public static Vector256<uint> CompareGreaterThanOrEqual(Vector256<uint> left, Vector256<uint> right) => CompareGreaterThanOrEqual(left, right); 645public static Vector256<uint> CompareLessThan(Vector256<uint> left, Vector256<uint> right) => CompareLessThan(left, right); 650public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> left, Vector256<uint> right) => CompareLessThanOrEqual(left, right); 655public static Vector256<uint> CompareNotEqual(Vector256<uint> left, Vector256<uint> right) => CompareNotEqual(left, right); 692public static Vector256<ulong> CompareEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareEqual(left, right); 697public static Vector256<ulong> CompareGreaterThan(Vector256<ulong> left, Vector256<ulong> right) => CompareGreaterThan(left, right); 702public static Vector256<ulong> CompareGreaterThanOrEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareGreaterThanOrEqual(left, right); 707public static Vector256<ulong> CompareLessThan(Vector256<ulong> left, Vector256<ulong> right) => CompareLessThan(left, right); 712public static Vector256<ulong> CompareLessThanOrEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareLessThanOrEqual(left, right); 717public static Vector256<ulong> CompareNotEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareNotEqual(left, right); 754public static Vector256<double> Compress(Vector256<double> merge, Vector256<double> mask, Vector256<double> value) => Compress(merge, mask, value); 759public static Vector256<int> Compress(Vector256<int> merge, Vector256<int> mask, Vector256<int> value) => Compress(merge, mask, value); 764public static Vector256<long> Compress(Vector256<long> merge, Vector256<long> mask, Vector256<long> value) => Compress(merge, mask, value); 769public static Vector256<float> Compress(Vector256<float> merge, Vector256<float> mask, Vector256<float> value) => Compress(merge, mask, value); 774public static Vector256<uint> Compress(Vector256<uint> merge, Vector256<uint> mask, Vector256<uint> value) => Compress(merge, mask, value); 779public static Vector256<ulong> Compress(Vector256<ulong> merge, Vector256<ulong> mask, Vector256<ulong> value) => Compress(merge, mask, value); 821public static unsafe void CompressStore(double* address, Vector256<double> mask, Vector256<double> source) => CompressStore(address, mask, source); 827public static unsafe void CompressStore(int* address, Vector256<int> mask, Vector256<int> source) => CompressStore(address, mask, source); 833public static unsafe void CompressStore(long* address, Vector256<long> mask, Vector256<long> source) => CompressStore(address, mask, source); 839public static unsafe void CompressStore(float* address, Vector256<float> mask, Vector256<float> source) => CompressStore(address, mask, source); 845public static unsafe void CompressStore(uint* address, Vector256<uint> mask, Vector256<uint> source) => CompressStore(address, mask, source); 851public static unsafe void CompressStore(ulong* address, Vector256<ulong> mask, Vector256<ulong> source) => CompressStore(address, mask, source); 877public static Vector128<byte> ConvertToVector128Byte(Vector256<int> value) => ConvertToVector128Byte(value); 882public static Vector128<byte> ConvertToVector128Byte(Vector256<long> value) => ConvertToVector128Byte(value); 887public static Vector128<byte> ConvertToVector128Byte(Vector256<uint> value) => ConvertToVector128Byte(value); 892public static Vector128<byte> ConvertToVector128Byte(Vector256<ulong> value) => ConvertToVector128Byte(value); 907public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<uint> value) => ConvertToVector128ByteWithSaturation(value); 912public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<ulong> value) => ConvertToVector128ByteWithSaturation(value); 944public static Vector128<short> ConvertToVector128Int16(Vector256<int> value) => ConvertToVector128Int16(value); 949public static Vector128<short> ConvertToVector128Int16(Vector256<long> value) => ConvertToVector128Int16(value); 954public static Vector128<short> ConvertToVector128Int16(Vector256<uint> value) => ConvertToVector128Int16(value); 959public static Vector128<short> ConvertToVector128Int16(Vector256<ulong> value) => ConvertToVector128Int16(value); 974public static Vector128<short> ConvertToVector128Int16WithSaturation(Vector256<int> value) => ConvertToVector128Int16WithSaturation(value); 979public static Vector128<short> ConvertToVector128Int16WithSaturation(Vector256<long> value) => ConvertToVector128Int16WithSaturation(value); 995public static Vector128<int> ConvertToVector128Int32(Vector256<long> value) => ConvertToVector128Int32(value); 1000public static Vector128<int> ConvertToVector128Int32(Vector256<ulong> value) => ConvertToVector128Int32(value); 1010public static Vector128<int> ConvertToVector128Int32WithSaturation(Vector256<long> value) => ConvertToVector128Int32WithSaturation(value); 1036public static Vector128<sbyte> ConvertToVector128SByte(Vector256<int> value) => ConvertToVector128SByte(value); 1041public static Vector128<sbyte> ConvertToVector128SByte(Vector256<long> value) => ConvertToVector128SByte(value); 1046public static Vector128<sbyte> ConvertToVector128SByte(Vector256<uint> value) => ConvertToVector128SByte(value); 1051public static Vector128<sbyte> ConvertToVector128SByte(Vector256<ulong> value) => ConvertToVector128SByte(value); 1066public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<int> value) => ConvertToVector128SByteWithSaturation(value); 1071public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<long> value) => ConvertToVector128SByteWithSaturation(value); 1103public static Vector128<ushort> ConvertToVector128UInt16(Vector256<int> value) => ConvertToVector128UInt16(value); 1108public static Vector128<ushort> ConvertToVector128UInt16(Vector256<long> value) => ConvertToVector128UInt16(value); 1113public static Vector128<ushort> ConvertToVector128UInt16(Vector256<uint> value) => ConvertToVector128UInt16(value); 1118public static Vector128<ushort> ConvertToVector128UInt16(Vector256<ulong> value) => ConvertToVector128UInt16(value); 1133public static Vector128<ushort> ConvertToVector128UInt16WithSaturation(Vector256<uint> value) => ConvertToVector128UInt16WithSaturation(value); 1138public static Vector128<ushort> ConvertToVector128UInt16WithSaturation(Vector256<ulong> value) => ConvertToVector128UInt16WithSaturation(value); 1164public static Vector128<uint> ConvertToVector128UInt32(Vector256<long> value) => ConvertToVector128UInt32(value); 1169public static Vector128<uint> ConvertToVector128UInt32(Vector256<ulong> value) => ConvertToVector128UInt32(value); 1174public static Vector128<uint> ConvertToVector128UInt32(Vector256<double> value) => ConvertToVector128UInt32(value); 1184public static Vector128<uint> ConvertToVector128UInt32WithSaturation(Vector256<ulong> value) => ConvertToVector128UInt32WithSaturation(value); 1199public static Vector128<uint> ConvertToVector128UInt32WithTruncation(Vector256<double> value) => ConvertToVector128UInt32WithTruncation(value); 1205public static Vector256<double> ConvertToVector256Double(Vector128<uint> value) => ConvertToVector256Double(value); 1210public static Vector256<float> ConvertToVector256Single(Vector256<uint> value) => ConvertToVector256Single(value); 1215public static Vector256<uint> ConvertToVector256UInt32(Vector256<float> value) => ConvertToVector256UInt32(value); 1220public static Vector256<uint> ConvertToVector256UInt32WithTruncation(Vector256<float> value) => ConvertToVector256UInt32WithTruncation(value); 1257public static Vector256<double> Expand(Vector256<double> merge, Vector256<double> mask, Vector256<double> value) => Expand(merge, mask, value); 1262public static Vector256<int> Expand(Vector256<int> merge, Vector256<int> mask, Vector256<int> value) => Expand(merge, mask, value); 1267public static Vector256<long> Expand(Vector256<long> merge, Vector256<long> mask, Vector256<long> value) => Expand(merge, mask, value); 1272public static Vector256<float> Expand(Vector256<float> merge, Vector256<float> mask, Vector256<float> value) => Expand(merge, mask, value); 1277public static Vector256<uint> Expand(Vector256<uint> merge, Vector256<uint> mask, Vector256<uint> value) => Expand(merge, mask, value); 1282public static Vector256<ulong> Expand(Vector256<ulong> merge, Vector256<ulong> mask, Vector256<ulong> value) => Expand(merge, mask, value); 1331public static unsafe Vector256<double> ExpandLoad(double* address, Vector256<double> mask, Vector256<double> merge) => ExpandLoad(address, mask, merge); 1338public static unsafe Vector256<int> ExpandLoad(int* address, Vector256<int> mask, Vector256<int> merge) => ExpandLoad(address, mask, merge); 1345public static unsafe Vector256<long> ExpandLoad(long* address, Vector256<long> mask, Vector256<long> merge) => ExpandLoad(address, mask, merge); 1352public static unsafe Vector256<float> ExpandLoad(float* address, Vector256<float> mask, Vector256<float> merge) => ExpandLoad(address, mask, merge); 1359public static unsafe Vector256<uint> ExpandLoad(uint* address, Vector256<uint> mask, Vector256<uint> merge) => ExpandLoad(address, mask, merge); 1366public static unsafe Vector256<ulong> ExpandLoad(ulong* address, Vector256<ulong> mask, Vector256<ulong> merge) => ExpandLoad(address, mask, merge); 1382public static Vector256<float> Fixup(Vector256<float> left, Vector256<float> right, Vector256<int> table, [ConstantExpected] byte control) => Fixup(left, right, table, control); 1387public static Vector256<double> Fixup(Vector256<double> left, Vector256<double> right, Vector256<long> table, [ConstantExpected] byte control) => Fixup(left, right, table, control); 1403public static Vector256<float> GetExponent(Vector256<float> value) => GetExponent(value); 1408public static Vector256<double> GetExponent(Vector256<double> value) => GetExponent(value); 1424public static Vector256<float> GetMantissa(Vector256<float> value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); 1429public static Vector256<double> GetMantissa(Vector256<double> value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); 1478public static unsafe Vector256<double> MaskLoad(double* address, Vector256<double> mask, Vector256<double> merge) => MaskLoad(address, mask, merge); 1484public static unsafe Vector256<int> MaskLoad(int* address, Vector256<int> mask, Vector256<int> merge) => MaskLoad(address, mask, merge); 1491public static unsafe Vector256<long> MaskLoad(long* address, Vector256<long> mask, Vector256<long> merge) => MaskLoad(address, mask, merge); 1498public static unsafe Vector256<float> MaskLoad(float* address, Vector256<float> mask, Vector256<float> merge) => MaskLoad(address, mask, merge); 1505public static unsafe Vector256<uint> MaskLoad(uint* address, Vector256<uint> mask, Vector256<uint> merge) => MaskLoad(address, mask, merge); 1512public static unsafe Vector256<ulong> MaskLoad(ulong* address, Vector256<ulong> mask, Vector256<ulong> merge) => MaskLoad(address, mask, merge); 1561public static unsafe Vector256<double> MaskLoadAligned(double* address, Vector256<double> mask, Vector256<double> merge) => MaskLoadAligned(address, mask, merge); 1568public static unsafe Vector256<int> MaskLoadAligned(int* address, Vector256<int> mask, Vector256<int> merge) => MaskLoadAligned(address, mask, merge); 1575public static unsafe Vector256<long> MaskLoadAligned(long* address, Vector256<long> mask, Vector256<long> merge) => MaskLoadAligned(address, mask, merge); 1582public static unsafe Vector256<float> MaskLoadAligned(float* address, Vector256<float> mask, Vector256<float> merge) => MaskLoadAligned(address, mask, merge); 1589public static unsafe Vector256<uint> MaskLoadAligned(uint* address, Vector256<uint> mask, Vector256<uint> merge) => MaskLoadAligned(address, mask, merge); 1596public static unsafe Vector256<ulong> MaskLoadAligned(ulong* address, Vector256<ulong> mask, Vector256<ulong> merge) => MaskLoadAligned(address, mask, merge); 1638public static unsafe void MaskStore(double* address, Vector256<double> mask, Vector256<double> source) => MaskStore(address, mask, source); 1644public static unsafe void MaskStore(int* address, Vector256<int> mask, Vector256<int> source) => MaskStore(address, mask, source); 1650public static unsafe void MaskStore(long* address, Vector256<long> mask, Vector256<long> source) => MaskStore(address, mask, source); 1656public static unsafe void MaskStore(float* address, Vector256<float> mask, Vector256<float> source) => MaskStore(address, mask, source); 1662public static unsafe void MaskStore(uint* address, Vector256<uint> mask, Vector256<uint> source) => MaskStore(address, mask, source); 1668public static unsafe void MaskStore(ulong* address, Vector256<ulong> mask, Vector256<ulong> source) => MaskStore(address, mask, source); 1710public static unsafe void MaskStoreAligned(double* address, Vector256<double> mask, Vector256<double> source) => MaskStoreAligned(address, mask, source); 1716public static unsafe void MaskStoreAligned(int* address, Vector256<int> mask, Vector256<int> source) => MaskStoreAligned(address, mask, source); 1722public static unsafe void MaskStoreAligned(long* address, Vector256<long> mask, Vector256<long> source) => MaskStoreAligned(address, mask, source); 1728public static unsafe void MaskStoreAligned(float* address, Vector256<float> mask, Vector256<float> source) => MaskStoreAligned(address, mask, source); 1734public static unsafe void MaskStoreAligned(uint* address, Vector256<uint> mask, Vector256<uint> source) => MaskStoreAligned(address, mask, source); 1740public static unsafe void MaskStoreAligned(ulong* address, Vector256<ulong> mask, Vector256<ulong> source) => MaskStoreAligned(address, mask, source); 1756public static Vector256<long> Max(Vector256<long> left, Vector256<long> right) => Max(left, right); 1761public static Vector256<ulong> Max(Vector256<ulong> left, Vector256<ulong> right) => Max(left, right); 1777public static Vector256<long> Min(Vector256<long> left, Vector256<long> right) => Min(left, right); 1782public static Vector256<ulong> Min(Vector256<ulong> left, Vector256<ulong> right) => Min(left, right); 1827public static Vector256<long> PermuteVar4x64(Vector256<long> value, Vector256<long> control) => PermuteVar4x64(value, control); 1833public static Vector256<ulong> PermuteVar4x64(Vector256<ulong> value, Vector256<ulong> control) => PermuteVar4x64(value, control); 1839public static Vector256<double> PermuteVar4x64(Vector256<double> value, Vector256<long> control) => PermuteVar4x64(value, control); 1846public static Vector256<long> PermuteVar4x64x2(Vector256<long> lower, Vector256<long> indices, Vector256<long> upper) => PermuteVar4x64x2(lower, indices, upper); 1852public static Vector256<ulong> PermuteVar4x64x2(Vector256<ulong> lower, Vector256<ulong> indices, Vector256<ulong> upper) => PermuteVar4x64x2(lower, indices, upper); 1858public static Vector256<double> PermuteVar4x64x2(Vector256<double> lower, Vector256<long> indices, Vector256<double> upper) => PermuteVar4x64x2(lower, indices, upper); 1865public static Vector256<int> PermuteVar8x32x2(Vector256<int> lower, Vector256<int> indices, Vector256<int> upper) => PermuteVar8x32x2(lower, indices, upper); 1871public static Vector256<uint> PermuteVar8x32x2(Vector256<uint> lower, Vector256<uint> indices, Vector256<uint> upper) => PermuteVar8x32x2(lower, indices, upper); 1877public static Vector256<float> PermuteVar8x32x2(Vector256<float> lower, Vector256<int> indices, Vector256<float> upper) => PermuteVar8x32x2(lower, indices, upper); 1893public static Vector256<float> Reciprocal14(Vector256<float> value) => Reciprocal14(value); 1898public static Vector256<double> Reciprocal14(Vector256<double> value) => Reciprocal14(value); 1914public static Vector256<float> ReciprocalSqrt14(Vector256<float> value) => ReciprocalSqrt14(value); 1919public static Vector256<double> ReciprocalSqrt14(Vector256<double> value) => ReciprocalSqrt14(value); 1945public static Vector256<int> RotateLeft(Vector256<int> value, [ConstantExpected] byte count) => RotateLeft(value, count); 1950public static Vector256<uint> RotateLeft(Vector256<uint> value, [ConstantExpected] byte count) => RotateLeft(value, count); 1955public static Vector256<long> RotateLeft(Vector256<long> value, [ConstantExpected] byte count) => RotateLeft(value, count); 1960public static Vector256<ulong> RotateLeft(Vector256<ulong> value, [ConstantExpected] byte count) => RotateLeft(value, count); 1986public static Vector256<int> RotateLeftVariable(Vector256<int> value, Vector256<uint> count) => RotateLeftVariable(value, count); 1991public static Vector256<uint> RotateLeftVariable(Vector256<uint> value, Vector256<uint> count) => RotateLeftVariable(value, count); 1996public static Vector256<long> RotateLeftVariable(Vector256<long> value, Vector256<ulong> count) => RotateLeftVariable(value, count); 2001public static Vector256<ulong> RotateLeftVariable(Vector256<ulong> value, Vector256<ulong> count) => RotateLeftVariable(value, count); 2027public static Vector256<int> RotateRight(Vector256<int> value, [ConstantExpected] byte count) => RotateRight(value, count); 2032public static Vector256<uint> RotateRight(Vector256<uint> value, [ConstantExpected] byte count) => RotateRight(value, count); 2037public static Vector256<long> RotateRight(Vector256<long> value, [ConstantExpected] byte count) => RotateRight(value, count); 2042public static Vector256<ulong> RotateRight(Vector256<ulong> value, [ConstantExpected] byte count) => RotateRight(value, count); 2068public static Vector256<int> RotateRightVariable(Vector256<int> value, Vector256<uint> count) => RotateRightVariable(value, count); 2073public static Vector256<uint> RotateRightVariable(Vector256<uint> value, Vector256<uint> count) => RotateRightVariable(value, count); 2078public static Vector256<long> RotateRightVariable(Vector256<long> value, Vector256<ulong> count) => RotateRightVariable(value, count); 2083public static Vector256<ulong> RotateRightVariable(Vector256<ulong> value, Vector256<ulong> count) => RotateRightVariable(value, count); 2099public static Vector256<float> RoundScale(Vector256<float> value, [ConstantExpected] byte control) => RoundScale(value, control); 2104public static Vector256<double> RoundScale(Vector256<double> value, [ConstantExpected] byte control) => RoundScale(value, control); 2120public static Vector256<float> Scale(Vector256<float> left, Vector256<float> right) => Scale(left, right); 2125public static Vector256<double> Scale(Vector256<double> left, Vector256<double> right) => Scale(left, right); 2136public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, Vector128<long> count) => ShiftRightArithmetic(value, count); 2147public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); 2158public static Vector256<long> ShiftRightArithmeticVariable(Vector256<long> value, Vector256<ulong> count) => ShiftRightArithmeticVariable(value, count); 2164public static Vector256<double> Shuffle2x128(Vector256<double> left, Vector256<double> right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); 2169public static Vector256<int> Shuffle2x128(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); 2174public static Vector256<long> Shuffle2x128(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); 2179public static Vector256<float> Shuffle2x128(Vector256<float> left, Vector256<float> right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); 2184public static Vector256<uint> Shuffle2x128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); 2189public static Vector256<ulong> Shuffle2x128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); 2252public static Vector256<sbyte> TernaryLogic(Vector256<sbyte> a, Vector256<sbyte> b, Vector256<sbyte> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 2258public static Vector256<byte> TernaryLogic(Vector256<byte> a, Vector256<byte> b, Vector256<byte> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 2264public static Vector256<short> TernaryLogic(Vector256<short> a, Vector256<short> b, Vector256<short> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 2270public static Vector256<ushort> TernaryLogic(Vector256<ushort> a, Vector256<ushort> b, Vector256<ushort> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 2275public static Vector256<int> TernaryLogic(Vector256<int> a, Vector256<int> b, Vector256<int> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 2280public static Vector256<uint> TernaryLogic(Vector256<uint> a, Vector256<uint> b, Vector256<uint> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 2285public static Vector256<long> TernaryLogic(Vector256<long> a, Vector256<long> b, Vector256<long> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 2290public static Vector256<ulong> TernaryLogic(Vector256<ulong> a, Vector256<ulong> b, Vector256<ulong> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 2296public static Vector256<float> TernaryLogic(Vector256<float> a, Vector256<float> b, Vector256<float> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 2302public static Vector256<double> TernaryLogic(Vector256<double> a, Vector256<double> b, Vector256<double> c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); 3179public static Vector256<short> ConvertToVector256Int16(Vector512<int> value) => ConvertToVector256Int16(value); 3184public static Vector256<short> ConvertToVector256Int16(Vector512<uint> value) => ConvertToVector256Int16(value); 3189public static Vector256<short> ConvertToVector256Int16WithSaturation(Vector512<int> value) => ConvertToVector256Int16WithSaturation(value); 3195public static Vector256<int> ConvertToVector256Int32(Vector512<double> value) => ConvertToVector256Int32(value); 3200public static Vector256<int> ConvertToVector256Int32(Vector512<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Int32(value, mode); 3205public static Vector256<int> ConvertToVector256Int32(Vector512<long> value) => ConvertToVector256Int32(value); 3210public static Vector256<int> ConvertToVector256Int32(Vector512<ulong> value) => ConvertToVector256Int32(value); 3215public static Vector256<int> ConvertToVector256Int32WithSaturation(Vector512<long> value) => ConvertToVector256Int32WithSaturation(value); 3220public static Vector256<int> ConvertToVector256Int32WithTruncation(Vector512<double> value) => ConvertToVector256Int32WithTruncation(value); 3227public static Vector256<float> ConvertToVector256Single(Vector512<double> value) => ConvertToVector256Single(value); 3232public static Vector256<float> ConvertToVector256Single(Vector512<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); 3238public static Vector256<ushort> ConvertToVector256UInt16(Vector512<int> value) => ConvertToVector256UInt16(value); 3243public static Vector256<ushort> ConvertToVector256UInt16(Vector512<uint> value) => ConvertToVector256UInt16(value); 3248public static Vector256<ushort> ConvertToVector256UInt16WithSaturation(Vector512<uint> value) => ConvertToVector256UInt16WithSaturation(value); 3254public static Vector256<uint> ConvertToVector256UInt32(Vector512<double> value) => ConvertToVector256UInt32(value); 3259public static Vector256<uint> ConvertToVector256UInt32(Vector512<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256UInt32(value, mode); 3264public static Vector256<uint> ConvertToVector256UInt32(Vector512<long> value) => ConvertToVector256UInt32(value); 3269public static Vector256<uint> ConvertToVector256UInt32(Vector512<ulong> value) => ConvertToVector256UInt32(value); 3274public static Vector256<uint> ConvertToVector256UInt32WithSaturation(Vector512<ulong> value) => ConvertToVector256UInt32WithSaturation(value); 3279public static Vector256<uint> ConvertToVector256UInt32WithTruncation(Vector512<double> value) => ConvertToVector256UInt32WithTruncation(value); 3285public static Vector512<double> ConvertToVector512Double(Vector256<int> value) => ConvertToVector512Double(value); 3290public static Vector512<double> ConvertToVector512Double(Vector256<float> value) => ConvertToVector512Double(value); 3295public static Vector512<double> ConvertToVector512Double(Vector256<uint> value) => ConvertToVector512Double(value); 3310public static Vector512<int> ConvertToVector512Int32(Vector256<short> value) => ConvertToVector512Int32(value); 3315public static Vector512<int> ConvertToVector512Int32(Vector256<ushort> value) => ConvertToVector512Int32(value); 3355public static Vector512<long> ConvertToVector512Int64(Vector256<int> value) => ConvertToVector512Int64(value); 3360public static Vector512<long> ConvertToVector512Int64(Vector256<uint> value) => ConvertToVector512Int64(value); 3395public static Vector512<uint> ConvertToVector512UInt32(Vector256<short> value) => ConvertToVector512UInt32(value); 3400public static Vector512<uint> ConvertToVector512UInt32(Vector256<ushort> value) => ConvertToVector512UInt32(value); 3440public static Vector512<ulong> ConvertToVector512UInt64(Vector256<int> value) => ConvertToVector512UInt64(value); 3445public static Vector512<ulong> ConvertToVector512UInt64(Vector256<uint> value) => ConvertToVector512UInt64(value); 3621public static Vector256<sbyte> ExtractVector256(Vector512<sbyte> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3626public static Vector256<byte> ExtractVector256(Vector512<byte> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3631public static Vector256<short> ExtractVector256(Vector512<short> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3636public static Vector256<ushort> ExtractVector256(Vector512<ushort> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3641public static Vector256<int> ExtractVector256(Vector512<int> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3646public static Vector256<uint> ExtractVector256(Vector512<uint> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3651public static Vector256<long> ExtractVector256(Vector512<long> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3656public static Vector256<ulong> ExtractVector256(Vector512<ulong> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3661public static Vector256<float> ExtractVector256(Vector512<float> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3666public static Vector256<double> ExtractVector256(Vector512<double> value, [ConstantExpected] byte index) => ExtractVector256(value, index); 3979public static Vector512<sbyte> InsertVector256(Vector512<sbyte> value, Vector256<sbyte> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 3984public static Vector512<byte> InsertVector256(Vector512<byte> value, Vector256<byte> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 3989public static Vector512<short> InsertVector256(Vector512<short> value, Vector256<short> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 3994public static Vector512<ushort> InsertVector256(Vector512<ushort> value, Vector256<ushort> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 3999public static Vector512<int> InsertVector256(Vector512<int> value, Vector256<int> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4004public static Vector512<uint> InsertVector256(Vector512<uint> value, Vector256<uint> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4009public static Vector512<long> InsertVector256(Vector512<long> value, Vector256<long> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4014public static Vector512<ulong> InsertVector256(Vector512<ulong> value, Vector256<ulong> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4019public static Vector512<float> InsertVector256(Vector512<float> value, Vector256<float> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4024public static Vector512<double> InsertVector256(Vector512<double> value, Vector256<double> data, [ConstantExpected] byte index) => InsertVector256(value, data, index); 4427public static int MoveMask(Vector256<short> value) => MoveMask(value); 4432public static int MoveMask(Vector256<ushort> value) => MoveMask(value);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Avx512Vbmi.cs (20)
49public static Vector256<byte> MultiShift(Vector256<byte> control, Vector256<ulong> value) => MultiShift(control, value); 54public static Vector256<sbyte> MultiShift(Vector256<sbyte> control, Vector256<long> value) => MultiShift(control, value); 87public static Vector256<sbyte> PermuteVar32x8(Vector256<sbyte> left, Vector256<sbyte> control) => PermuteVar32x8(left, control); 93public static Vector256<byte> PermuteVar32x8(Vector256<byte> left, Vector256<byte> control) => PermuteVar32x8(left, control); 100public static Vector256<byte> PermuteVar32x8x2(Vector256<byte> lower, Vector256<byte> indices, Vector256<byte> upper) => PermuteVar32x8x2(lower, indices, upper); 106public static Vector256<sbyte> PermuteVar32x8x2(Vector256<sbyte> lower, Vector256<sbyte> indices, Vector256<sbyte> upper) => PermuteVar32x8x2(lower, indices, upper);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Avx512Vbmi2.cs (52)
59public static Vector256<byte> Compress(Vector256<byte> merge, Vector256<byte> mask, Vector256<byte> value) => Compress(merge, mask, value); 64public static Vector256<short> Compress(Vector256<short> merge, Vector256<short> mask, Vector256<short> value) => Compress(merge, mask, value); 69public static Vector256<sbyte> Compress(Vector256<sbyte> merge, Vector256<sbyte> mask, Vector256<sbyte> value) => Compress(merge, mask, value); 74public static Vector256<ushort> Compress(Vector256<ushort> merge, Vector256<ushort> mask, Vector256<ushort> value) => Compress(merge, mask, value); 104public static unsafe void CompressStore(byte* address, Vector256<byte> mask, Vector256<byte> source) => CompressStore(address, mask, source); 110public static unsafe void CompressStore(short* address, Vector256<short> mask, Vector256<short> source) => CompressStore(address, mask, source); 116public static unsafe void CompressStore(sbyte* address, Vector256<sbyte> mask, Vector256<sbyte> source) => CompressStore(address, mask, source); 122public static unsafe void CompressStore(ushort* address, Vector256<ushort> mask, Vector256<ushort> source) => CompressStore(address, mask, source); 149public static Vector256<byte> Expand(Vector256<byte> merge, Vector256<byte> mask, Vector256<byte> value) => Expand(merge, mask, value); 154public static Vector256<short> Expand(Vector256<short> merge, Vector256<short> mask, Vector256<short> value) => Expand(merge, mask, value); 159public static Vector256<sbyte> Expand(Vector256<sbyte> merge, Vector256<sbyte> mask, Vector256<sbyte> value) => Expand(merge, mask, value); 164public static Vector256<ushort> Expand(Vector256<ushort> merge, Vector256<ushort> mask, Vector256<ushort> value) => Expand(merge, mask, value); 199public static unsafe Vector256<byte> ExpandLoad(byte* address, Vector256<byte> mask, Vector256<byte> merge) => ExpandLoad(address, mask, merge); 206public static unsafe Vector256<short> ExpandLoad(short* address, Vector256<short> mask, Vector256<short> merge) => ExpandLoad(address, mask, merge); 213public static unsafe Vector256<sbyte> ExpandLoad(sbyte* address, Vector256<sbyte> mask, Vector256<sbyte> merge) => ExpandLoad(address, mask, merge); 220public static unsafe Vector256<ushort> ExpandLoad(ushort* address, Vector256<ushort> mask, Vector256<ushort> merge) => ExpandLoad(address, mask, merge);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\AvxVnni.cs (16)
48public static Vector256<int> MultiplyWideningAndAdd(Vector256<int> addend, Vector256<byte> left, Vector256<sbyte> right) => MultiplyWideningAndAdd(addend, left, right); 54public static Vector256<int> MultiplyWideningAndAdd(Vector256<int> addend, Vector256<short> left, Vector256<short> right) => MultiplyWideningAndAdd(addend, left, right); 72public static Vector256<int> MultiplyWideningAndAddSaturate(Vector256<int> addend, Vector256<byte> left, Vector256<sbyte> right) => MultiplyWideningAndAddSaturate(addend, left, right); 78public static Vector256<int> MultiplyWideningAndAddSaturate(Vector256<int> addend, Vector256<short> left, Vector256<short> right) => MultiplyWideningAndAddSaturate(addend, left, right);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\AvxVnniInt16.cs (24)
42public static Vector256<int> MultiplyWideningAndAdd(Vector256<int> addend, Vector256<short> left, Vector256<ushort> right) => MultiplyWideningAndAdd(addend, left, right); 45public static Vector256<int> MultiplyWideningAndAdd(Vector256<int> addend, Vector256<ushort> left, Vector256<short> right) => MultiplyWideningAndAdd(addend, left, right); 48public static Vector256<uint> MultiplyWideningAndAdd(Vector256<uint> addend, Vector256<ushort> left, Vector256<ushort> right) => MultiplyWideningAndAdd(addend, left, right); 60public static Vector256<int> MultiplyWideningAndAddSaturate(Vector256<int> addend, Vector256<short> left, Vector256<ushort> right) => MultiplyWideningAndAddSaturate(addend, left, right); 63public static Vector256<int> MultiplyWideningAndAddSaturate(Vector256<int> addend, Vector256<ushort> left, Vector256<short> right) => MultiplyWideningAndAddSaturate(addend, left, right); 66public static Vector256<uint> MultiplyWideningAndAddSaturate(Vector256<uint> addend, Vector256<ushort> left, Vector256<ushort> right) => MultiplyWideningAndAddSaturate(addend, left, right);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\AvxVnniInt8.cs (24)
43public static Vector256<int> MultiplyWideningAndAdd(Vector256<int> addend, Vector256<sbyte> left, Vector256<sbyte> right) => MultiplyWideningAndAdd(addend, left, right); 46public static Vector256<int> MultiplyWideningAndAdd(Vector256<int> addend, Vector256<sbyte> left, Vector256<byte> right) => MultiplyWideningAndAdd(addend, left, right); 49public static Vector256<uint> MultiplyWideningAndAdd(Vector256<uint> addend, Vector256<byte> left, Vector256<byte> right) => MultiplyWideningAndAdd(addend, left, right); 61public static Vector256<int> MultiplyWideningAndAddSaturate(Vector256<int> addend, Vector256<sbyte> left, Vector256<sbyte> right) => MultiplyWideningAndAddSaturate(addend, left, right); 64public static Vector256<int> MultiplyWideningAndAddSaturate(Vector256<int> addend, Vector256<sbyte> left, Vector256<byte> right) => MultiplyWideningAndAddSaturate(addend, left, right); 67public static Vector256<uint> MultiplyWideningAndAddSaturate(Vector256<uint> addend, Vector256<byte> left, Vector256<byte> right) => MultiplyWideningAndAddSaturate(addend, left, right);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Fma.cs (48)
49public static Vector256<float> MultiplyAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c) => MultiplyAdd(a, b, c); 55public static Vector256<double> MultiplyAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplyAdd(a, b, c); 87public static Vector256<float> MultiplyAddSubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c) => MultiplyAddSubtract(a, b, c); 93public static Vector256<double> MultiplyAddSubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplyAddSubtract(a, b, c); 112public static Vector256<float> MultiplySubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c) => MultiplySubtract(a, b, c); 118public static Vector256<double> MultiplySubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplySubtract(a, b, c); 150public static Vector256<float> MultiplySubtractAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c) => MultiplySubtractAdd(a, b, c); 156public static Vector256<double> MultiplySubtractAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplySubtractAdd(a, b, c); 175public static Vector256<float> MultiplyAddNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c) => MultiplyAddNegated(a, b, c); 181public static Vector256<double> MultiplyAddNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplyAddNegated(a, b, c); 213public static Vector256<float> MultiplySubtractNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c) => MultiplySubtractNegated(a, b, c); 219public static Vector256<double> MultiplySubtractNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) => MultiplySubtractNegated(a, b, c);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Gfni.cs (9)
49public static Vector256<byte> GaloisFieldAffineTransformInverse(Vector256<byte> x, Vector256<byte> a, [ConstantExpected] byte b) => GaloisFieldAffineTransformInverse(x, a, b); 56public static Vector256<byte> GaloisFieldAffineTransform(Vector256<byte> x, Vector256<byte> a, [ConstantExpected] byte b) => GaloisFieldAffineTransform(x, a, b); 63public static Vector256<byte> GaloisFieldMultiply(Vector256<byte> left, Vector256<byte> right) => GaloisFieldMultiply(left, right);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\Pclmulqdq.Wide.cs (6)
25public static Vector256<long> CarrylessMultiply(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte control) => CarrylessMultiply(left, right, control); 30public static Vector256<ulong> CarrylessMultiply(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte control) => CarrylessMultiply(left, right, control);
src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\IndexOfAnyAsciiSearcher.cs (137)
20public Vector256<byte> Bitmap = Vector256.Create(bitmap); 29public readonly Vector256<byte> Bitmap0 = Vector256.Create(bitmap0); 30public readonly Vector256<byte> Bitmap1 = Vector256.Create(bitmap1); 316Vector256<byte> bitmap256 = state.Bitmap; 318if (searchSpaceLength > 2 * Vector256<short>.Count) 326ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - (2 * Vector256<short>.Count)); 330Vector256<short> source0 = Vector256.LoadUnsafe(ref currentSearchSpace); 331Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 333Vector256<byte> result = IndexOfAnyLookup<TNegator, TOptimizations, TUniqueLowNibble>(source0, source1, bitmap256); 334if (result != Vector256<byte>.Zero) 339currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count); 346Debug.Assert(searchSpaceLength >= Vector256<short>.Count, "We expect that the input is long enough for us to load a whole vector."); 348ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector256<short>.Count); 354Vector256<short> source0 = Vector256.LoadUnsafe(ref firstVector); 355Vector256<short> source1 = Vector256.LoadUnsafe(ref oneVectorAwayFromEnd); 357Vector256<byte> result = IndexOfAnyLookup<TNegator, TOptimizations, TUniqueLowNibble>(source0, source1, bitmap256); 358if (result != Vector256<byte>.Zero) 448Vector256<byte> bitmap256 = state.Bitmap; 450if (searchSpaceLength > 2 * Vector256<short>.Count) 458ref short twoVectorsAfterStart = ref Unsafe.Add(ref searchSpace, 2 * Vector256<short>.Count); 462currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, 2 * Vector256<short>.Count); 464Vector256<short> source0 = Vector256.LoadUnsafe(ref currentSearchSpace); 465Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 467Vector256<byte> result = IndexOfAnyLookup<TNegator, TOptimizations, TUniqueLowNibble>(source0, source1, bitmap256); 468if (result != Vector256<byte>.Zero) 478Debug.Assert(searchSpaceLength >= Vector256<short>.Count, "We expect that the input is long enough for us to load a whole vector."); 480ref short oneVectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector256<short>.Count); 483? ref Unsafe.Subtract(ref currentSearchSpace, Vector256<short>.Count) 486Vector256<short> source0 = Vector256.LoadUnsafe(ref searchSpace); 487Vector256<short> source1 = Vector256.LoadUnsafe(ref secondVector); 489Vector256<byte> result = IndexOfAnyLookup<TNegator, TOptimizations, TUniqueLowNibble>(source0, source1, bitmap256); 490if (result != Vector256<byte>.Zero) 601Vector256<byte> bitmap256 = state.Bitmap; 603if (searchSpaceLength > Vector256<byte>.Count) 609ref byte vectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector256<byte>.Count); 613Vector256<byte> source = Vector256.LoadUnsafe(ref currentSearchSpace); 615Vector256<byte> result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore<TUniqueLowNibble>(source, bitmap256)); 616if (result != Vector256<byte>.Zero) 621currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<byte>.Count); 638Vector256<byte> source = Vector256.Create(source0, source1); 640Vector256<byte> result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore<TUniqueLowNibble>(source, bitmap256)); 641if (result != Vector256<byte>.Zero) 726Vector256<byte> bitmap256 = state.Bitmap; 728if (searchSpaceLength > Vector256<byte>.Count) 734ref byte vectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector256<byte>.Count); 738currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector256<byte>.Count); 740Vector256<byte> source = Vector256.LoadUnsafe(ref currentSearchSpace); 742Vector256<byte> result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore<TUniqueLowNibble>(source, bitmap256)); 743if (result != Vector256<byte>.Zero) 763Vector256<byte> source = Vector256.Create(source0, source1); 765Vector256<byte> result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore<TUniqueLowNibble>(source, bitmap256)); 766if (result != Vector256<byte>.Zero) 872Vector256<byte> bitmap256_0 = state.Bitmap0; 873Vector256<byte> bitmap256_1 = state.Bitmap1; 875if (searchSpaceLength > Vector256<byte>.Count) 881ref byte vectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector256<byte>.Count); 885Vector256<byte> source = Vector256.LoadUnsafe(ref currentSearchSpace); 887Vector256<byte> result = IndexOfAnyLookup<TNegator>(source, bitmap256_0, bitmap256_1); 888if (result != Vector256<byte>.Zero) 893currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<byte>.Count); 910Vector256<byte> source = Vector256.Create(source0, source1); 912Vector256<byte> result = IndexOfAnyLookup<TNegator>(source, bitmap256_0, bitmap256_1); 913if (result != Vector256<byte>.Zero) 1000Vector256<byte> bitmap256_0 = state.Bitmap0; 1001Vector256<byte> bitmap256_1 = state.Bitmap1; 1003if (searchSpaceLength > Vector256<byte>.Count) 1009ref byte vectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector256<byte>.Count); 1013currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector256<byte>.Count); 1015Vector256<byte> source = Vector256.LoadUnsafe(ref currentSearchSpace); 1017Vector256<byte> result = IndexOfAnyLookup<TNegator>(source, bitmap256_0, bitmap256_1); 1018if (result != Vector256<byte>.Zero) 1038Vector256<byte> source = Vector256.Create(source0, source1); 1040Vector256<byte> result = IndexOfAnyLookup<TNegator>(source, bitmap256_0, bitmap256_1); 1041if (result != Vector256<byte>.Zero) 1172private static Vector256<byte> IndexOfAnyLookup<TNegator, TOptimizations, TUniqueLowNibble>(Vector256<short> source0, Vector256<short> source1, Vector256<byte> bitmapLookup) 1177Vector256<byte> source = TOptimizations.PackSources(source0.AsUInt16(), source1.AsUInt16()); 1179Vector256<byte> result = IndexOfAnyLookupCore<TUniqueLowNibble>(source, bitmapLookup); 1186private static Vector256<byte> IndexOfAnyLookupCore<TUniqueLowNibble>(Vector256<byte> source, Vector256<byte> bitmapLookup) 1192Vector256<byte> values = Avx2.Shuffle(bitmapLookup, source); 1197Vector256<byte> highNibbles = source >>> 4; 1198Vector256<byte> bitMask = Avx2.Shuffle(bitmapLookup, source); 1199Vector256<byte> bitPositions = Avx2.Shuffle(Vector256.Create(0x8040201008040201).AsByte(), highNibbles); 1231private static Vector256<byte> IndexOfAnyLookup<TNegator>(Vector256<byte> source, Vector256<byte> bitmapLookup0, Vector256<byte> bitmapLookup1) 1236Vector256<byte> lowNibbles = source & Vector256.Create((byte)0xF); 1237Vector256<byte> highNibbles = source >>> 4; 1239Vector256<byte> row0 = Avx2.Shuffle(bitmapLookup0, lowNibbles); 1240Vector256<byte> row1 = Avx2.Shuffle(bitmapLookup1, lowNibbles); 1242Vector256<byte> bitmask = Avx2.Shuffle(Vector256.Create(0x8040201008040201).AsByte(), highNibbles); 1244Vector256<byte> mask = Vector256.GreaterThan(highNibbles.AsSByte(), Vector256.Create((sbyte)0x7)).AsByte(); 1245Vector256<byte> bitsets = Vector256.ConditionalSelect(mask, row1, row0); 1247Vector256<byte> result = Vector256.Equals(bitsets & bitmask, bitmask); 1277private static unsafe int ComputeLastIndex<T, TNegator>(ref T searchSpace, ref T current, Vector256<byte> result) 1291private static unsafe int ComputeLastIndexOverlapped<T, TNegator>(ref T searchSpace, ref T secondVector, Vector256<byte> result) 1301if (offsetInVector < Vector256<short>.Count) 1307return offsetInVector - Vector256<short>.Count + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref secondVector) / (nuint)sizeof(T)); 1314static abstract Vector256<byte> NegateIfNeeded(Vector256<byte> result); 1316static abstract int IndexOfFirstMatch(Vector256<byte> result); 1318static abstract int IndexOfLastMatch(Vector256<byte> result); 1325public static Vector256<byte> NegateIfNeeded(Vector256<byte> result) => result; 1329public static int IndexOfFirstMatch(Vector256<byte> result) => Vector256.IndexOfFirstMatch(~Vector256.Equals(result, Vector256<byte>.Zero)); 1333public static int IndexOfLastMatch(Vector256<byte> result) => Vector256.IndexOfLastMatch(~Vector256.Equals(result, Vector256<byte>.Zero)); 1348public static Vector256<byte> NegateIfNeeded(Vector256<byte> result) => Vector256.Equals(result, Vector256<byte>.Zero); 1359public static int IndexOfFirstMatch(Vector256<byte> result) => Vector256.IndexOfFirstMatch(result); 1370public static int IndexOfLastMatch(Vector256<byte> result) => Vector256.IndexOfLastMatch(result); 1382static abstract Vector256<byte> PackSources(Vector256<ushort> lower, Vector256<ushort> upper); 1415public static Vector256<byte> PackSources(Vector256<ushort> lower, Vector256<ushort> upper) 1453public static Vector256<byte> PackSources(Vector256<ushort> lower, Vector256<ushort> upper) 1466static abstract TResult FirstIndex<TNegator>(ref T searchSpace, ref T current, Vector256<byte> result) where TNegator : struct, INegator; 1468static abstract TResult FirstIndexOverlapped<TNegator>(ref T searchSpace, ref T current0, ref T current1, Vector256<byte> result) where TNegator : struct, INegator; 1477public static bool FirstIndex<TNegator>(ref T searchSpace, ref T current, Vector256<byte> result) where TNegator : struct, INegator => true; 1479public static bool FirstIndexOverlapped<TNegator>(ref T searchSpace, ref T current0, ref T current1, Vector256<byte> result) where TNegator : struct, INegator => true; 1501public static int FirstIndex<TNegator>(ref T searchSpace, ref T current, Vector256<byte> result) where TNegator : struct, INegator 1528public static int FirstIndexOverlapped<TNegator>(ref T searchSpace, ref T current0, ref T current1, Vector256<byte> result) where TNegator : struct, INegator 1537if (offsetInVector >= Vector256<short>.Count) 1541offsetInVector -= Vector256<short>.Count;
src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticMap.cs (57)
149private static Vector256<byte> ContainsMask32CharsAvx512(Vector256<byte> charMap, ref char searchSpace0, ref char searchSpace1) 151Vector256<ushort> source0 = Vector256.LoadUnsafe(ref searchSpace0); 152Vector256<ushort> source1 = Vector256.LoadUnsafe(ref searchSpace1); 154Vector256<byte> sourceLower = Avx512Vbmi.VL.PermuteVar32x8x2(source0.AsByte(), Vector256.CreateSequence<byte>(0, 2), source1.AsByte()); 155Vector256<byte> sourceUpper = Avx512Vbmi.VL.PermuteVar32x8x2(source0.AsByte(), Vector256.CreateSequence<byte>(1, 2), source1.AsByte()); 157Vector256<byte> resultLower = IsCharBitNotSetAvx512(charMap, sourceLower); 158Vector256<byte> resultUpper = IsCharBitNotSetAvx512(charMap, sourceUpper); 165private static Vector256<byte> IsCharBitNotSetAvx512(Vector256<byte> charMap, Vector256<byte> values) 171Vector256<byte> shifted = (values.AsInt32() >>> VectorizedIndexShift).AsByte(); 173Vector256<byte> bitPositions = Avx512Vbmi.VL.PermuteVar32x8(Vector256.Create(0x8040201008040201).AsByte(), shifted); 177Vector256<byte> bitMask = Avx512Vbmi.VL.PermuteVar32x8(charMap, values); 179return Vector256.Equals(bitMask & bitPositions, Vector256<byte>.Zero); 184private static Vector256<byte> ContainsMask32CharsAvx2(Vector256<byte> charMapLower, Vector256<byte> charMapUpper, ref char searchSpace) 186Vector256<ushort> source0 = Vector256.LoadUnsafe(ref searchSpace); 187Vector256<ushort> source1 = Vector256.LoadUnsafe(ref searchSpace, (nuint)Vector256<ushort>.Count); 189Vector256<byte> sourceLower = Avx2.PackUnsignedSaturate( 193Vector256<byte> sourceUpper = Avx2.PackUnsignedSaturate( 197Vector256<byte> resultLower = IsCharBitNotSetAvx2(charMapLower, charMapUpper, sourceLower); 198Vector256<byte> resultUpper = IsCharBitNotSetAvx2(charMapLower, charMapUpper, sourceUpper); 205private static Vector256<byte> IsCharBitNotSetAvx2(Vector256<byte> charMapLower, Vector256<byte> charMapUpper, Vector256<byte> values) 207Vector256<byte> shifted = values >>> VectorizedIndexShift; 209Vector256<byte> bitPositions = Avx2.Shuffle(Vector256.Create(0x8040201008040201).AsByte(), shifted); 211Vector256<byte> index = values & Vector256.Create((byte)VectorizedIndexMask); 212Vector256<byte> bitMaskLower = Avx2.Shuffle(charMapLower, index); 213Vector256<byte> bitMaskUpper = Avx2.Shuffle(charMapUpper, index - Vector256.Create((byte)16)); 214Vector256<byte> mask = Vector256.GreaterThan(index, Vector256.Create((byte)15)); 215Vector256<byte> bitMask = Vector256.ConditionalSelect(mask, bitMaskUpper, bitMaskLower); 217return Vector256.Equals(bitMask & bitPositions, Vector256<byte>.Zero); 434Vector256<byte> charMap256 = Vector256.LoadUnsafe(ref Unsafe.As<ProbabilisticMap, byte>(ref state.Map)); 494Vector256<byte> result = ContainsMask32CharsAvx512(charMap256, ref searchSpace, ref Unsafe.Subtract(ref searchSpaceEnd, Vector256<ushort>.Count)); 496if (result != Vector256<byte>.Zero) 527Vector256<byte> charMapLower256 = Vector256.Create(charMapLower); 528Vector256<byte> charMapUpper256 = Vector256.Create(charMapUpper); 534Vector256<byte> result = ContainsMask32CharsAvx2(charMapLower256, charMapUpper256, ref cur); 536if (result != Vector256<byte>.Zero) 610Vector256<byte> charMap256 = Vector256.LoadUnsafe(ref Unsafe.As<ProbabilisticMap, byte>(ref state.Map)); 673Vector256<byte> result = ContainsMask32CharsAvx512(charMap256, ref searchSpace, ref Unsafe.Subtract(ref cur, Vector256<ushort>.Count)); 675if (result != Vector256<byte>.Zero) 705Vector256<byte> charMapLower256 = Vector256.Create(charMapLower); 706Vector256<byte> charMapUpper256 = Vector256.Create(charMapUpper); 716Vector256<byte> result = ContainsMask32CharsAvx2(charMapLower256, charMapUpper256, ref cur); 718if (result != Vector256<byte>.Zero) 816if (index >= Vector256<ushort>.Count) 820index += searchSpaceLength - (2 * Vector256<ushort>.Count); 918if (index >= Vector256<ushort>.Count) 922index += searchSpaceLength - (2 * Vector256<ushort>.Count);
src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\AsciiStringSearchValuesTeddyBase.cs (22)
263Vector256<byte> n0Low = _n0Low._lower, n0High = _n0High._lower; 264Vector256<byte> n1Low = _n1Low._lower, n1High = _n1High._lower; 265Vector256<byte> prev0 = Vector256<byte>.AllBitsSet; 269Vector256<byte> input = TStartCaseSensitivity.TransformInput(LoadAndPack32AsciiChars(ref searchSpace)); 271(Vector256<byte> result, prev0) = ProcessInputN2(input, prev0, n0Low, n0High, n1Low, n1High); 273if (result != Vector256<byte>.Zero) 290prev0 = Vector256<byte>.AllBitsSet; 441Vector256<byte> n0Low = _n0Low._lower, n0High = _n0High._lower; 442Vector256<byte> n1Low = _n1Low._lower, n1High = _n1High._lower; 443Vector256<byte> n2Low = _n2Low._lower, n2High = _n2High._lower; 444Vector256<byte> prev0 = Vector256<byte>.AllBitsSet; 445Vector256<byte> prev1 = Vector256<byte>.AllBitsSet; 449Vector256<byte> input = TStartCaseSensitivity.TransformInput(LoadAndPack32AsciiChars(ref searchSpace)); 451(Vector256<byte> result, prev0, prev1) = ProcessInputN3(input, prev0, prev1, n0Low, n0High, n1Low, n1High, n2Low, n2High); 453if (result != Vector256<byte>.Zero) 470prev0 = Vector256<byte>.AllBitsSet; 471prev1 = Vector256<byte>.AllBitsSet; 588private bool TryFindMatch(ReadOnlySpan<char> span, ref char searchSpace, Vector256<byte> result, int matchStartOffset, out int offsetFromStart) 592uint resultMask = (~Vector256.Equals(result, Vector256<byte>.Zero)).ExtractMostSignificantBits();
src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\StringSearchValuesHelper.cs (19)
106public readonly Vector256<ushort> Value256; 107public readonly Vector256<ushort> ToUpperMask256; 174Vector256<ushort> isAsciiLetter = 191Vector256<ushort> input = Vector256.Create( 213Vector256<ushort> input = Vector256.Create( 232static abstract Vector256<byte> TransformInput(Vector256<byte> input); 247public static Vector256<byte> TransformInput(Vector256<byte> input) => input; 314public static Vector256<byte> TransformInput(Vector256<byte> input) => input & Vector256.Create(unchecked((byte)~0x20)); 391public static Vector256<byte> TransformInput(Vector256<byte> input) 393Vector256<byte> subtraction = Vector256.Create((byte)(128 + 'a')); 394Vector256<byte> comparison = Vector256.Create((byte)(128 + 26)); 395Vector256<byte> caseConversion = Vector256.Create((byte)0x20); 397Vector256<byte> matches = Vector256.LessThan((input - subtraction).AsSByte(), comparison.AsSByte()).AsByte(); 449public static Vector256<byte> TransformInput(Vector256<byte> input) => throw new UnreachableException();
src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\TeddyHelper.cs (59)
50public static (Vector256<byte> Result, Vector256<byte> Prev0) ProcessInputN2( 51Vector256<byte> input, 52Vector256<byte> prev0, 53Vector256<byte> n0Low, Vector256<byte> n0High, 54Vector256<byte> n1Low, Vector256<byte> n1High) 58(Vector256<byte> low, Vector256<byte> high) = GetNibbles(input); 60Vector256<byte> match0 = Shuffle(n0Low, n0High, low, high); 61Vector256<byte> result1 = Shuffle(n1Low, n1High, low, high); 63Vector256<byte> result0 = RightShift1(prev0, match0); 65Vector256<byte> result = result0 & result1; 165public static (Vector256<byte> Result, Vector256<byte> Prev0, Vector256<byte> Prev1) ProcessInputN3( 166Vector256<byte> input, 167Vector256<byte> prev0, Vector256<byte> prev1, 168Vector256<byte> n0Low, Vector256<byte> n0High, 169Vector256<byte> n1Low, Vector256<byte> n1High, 170Vector256<byte> n2Low, Vector256<byte> n2High) 174(Vector256<byte> low, Vector256<byte> high) = GetNibbles(input); 176Vector256<byte> match0 = Shuffle(n0Low, n0High, low, high); 177Vector256<byte> match1 = Shuffle(n1Low, n1High, low, high); 178Vector256<byte> result2 = Shuffle(n2Low, n2High, low, high); 180Vector256<byte> result0 = RightShift2(prev0, match0); 181Vector256<byte> result1 = RightShift1(prev1, match1); 183Vector256<byte> result = result0 & result1 & result2; 249/// Read two <see cref="Vector256&lt;UInt16&gt;" /> and concatenate their lower bytes together into a single <see cref="Vector256&lt;Byte&gt;" />. 256public static Vector256<byte> LoadAndPack32AsciiChars(ref char source) 258Vector256<ushort> source0 = Vector256.LoadUnsafe(ref source); 259Vector256<ushort> source1 = Vector256.LoadUnsafe(ref source, (nuint)Vector256<ushort>.Count); 261Vector256<byte> packed = Avx2.PackUnsignedSaturate(source0.AsInt16(), source1.AsInt16()); 304private static (Vector256<byte> Low, Vector256<byte> High) GetNibbles(Vector256<byte> input) 308Vector256<byte> low = input; 310Vector256<byte> high = input >>> 4; 338private static Vector256<byte> Shuffle(Vector256<byte> maskLow, Vector256<byte> maskHigh, Vector256<byte> low, Vector256<byte> high) 428private static Vector256<byte> RightShift1(Vector256<byte> left, Vector256<byte> right) 449Vector256<byte> leftShifted = Avx2.Permute2x128(left, right, (1 << 0) + (2 << 4)); 455private static Vector256<byte> RightShift2(Vector256<byte> left, Vector256<byte> right) 458Vector256<byte> leftShifted = Avx2.Permute2x128(left, right, (1 << 0) + (2 << 4));
src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\SingleStringSearchValuesPackedThreeChars.cs (25)
138else if (Vector256.IsHardwareAccelerated && Avx2.IsSupported && searchSpaceMinusValueTailLength - Vector256<byte>.Count >= 0) 140Vector256<byte> ch1 = Vector256.Create(_ch1); 141Vector256<byte> ch2 = Vector256.Create(_ch2); 142Vector256<byte> ch3 = Vector256.Create(_ch3); 144ref char lastSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceMinusValueTailLength - Vector256<byte>.Count); 148ValidateReadPosition(ref searchSpaceStart, searchSpaceLength, ref searchSpace, Vector256<byte>.Count); 149ValidateReadPosition(ref searchSpaceStart, searchSpaceLength, ref searchSpace, Vector256<byte>.Count + (int)(_ch2ByteOffset / sizeof(char))); 150ValidateReadPosition(ref searchSpaceStart, searchSpaceLength, ref searchSpace, Vector256<byte>.Count + (int)(_ch3ByteOffset / sizeof(char))); 153Vector256<byte> result = GetComparisonResult(ref searchSpace, ch2ByteOffset, ch3ByteOffset, ch1, ch2, ch3); 155if (result != Vector256<byte>.Zero) 161searchSpace = ref Unsafe.Add(ref searchSpace, Vector256<byte>.Count); 165if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpace, Vector256<byte>.Count))) 282private static Vector256<byte> GetComparisonResult(ref char searchSpace, nuint ch2ByteOffset, nuint ch3ByteOffset, Vector256<byte> ch1, Vector256<byte> ch2, Vector256<byte> ch3) 288Vector256<byte> cmpCh1 = Vector256.Equals(ch1, LoadPacked256(ref searchSpace, 0)); 289Vector256<byte> cmpCh2 = Vector256.Equals(ch2, LoadPacked256(ref searchSpace, ch2ByteOffset)); 290Vector256<byte> cmpCh3 = Vector256.Equals(ch3, LoadPacked256(ref searchSpace, ch3ByteOffset)); 295Vector256<byte> caseConversion = Vector256.Create(CaseConversionMask); 297Vector256<byte> cmpCh1 = Vector256.Equals(ch1, LoadPacked256(ref searchSpace, 0) & caseConversion); 298Vector256<byte> cmpCh2 = Vector256.Equals(ch2, LoadPacked256(ref searchSpace, ch2ByteOffset) & caseConversion); 299Vector256<byte> cmpCh3 = Vector256.Equals(ch3, LoadPacked256(ref searchSpace, ch3ByteOffset) & caseConversion); 405private static Vector256<byte> LoadPacked256(ref char searchSpace, nuint byteOffset) => 408Vector256.LoadUnsafe(ref Unsafe.AddByteOffset(ref searchSpace, byteOffset + (uint)Vector256<byte>.Count)).AsInt16());
src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\SingleStringSearchValuesThreeChars.cs (23)
138else if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector256<ushort>.Count >= 0) 140Vector256<ushort> ch1 = Vector256.Create(_ch1); 141Vector256<ushort> ch2 = Vector256.Create(_ch2); 142Vector256<ushort> ch3 = Vector256.Create(_ch3); 144ref char lastSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceMinusValueTailLength - Vector256<ushort>.Count); 148ValidateReadPosition(ref searchSpaceStart, searchSpaceLength, ref searchSpace, Vector256<ushort>.Count); 149ValidateReadPosition(ref searchSpaceStart, searchSpaceLength, ref searchSpace, Vector256<ushort>.Count + (int)(_ch2ByteOffset / sizeof(char))); 150ValidateReadPosition(ref searchSpaceStart, searchSpaceLength, ref searchSpace, Vector256<ushort>.Count + (int)(_ch3ByteOffset / sizeof(char))); 153Vector256<byte> result = GetComparisonResult(ref searchSpace, ch2ByteOffset, ch3ByteOffset, ch1, ch2, ch3); 155if (result != Vector256<byte>.Zero) 161searchSpace = ref Unsafe.Add(ref searchSpace, Vector256<ushort>.Count); 165if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpace, Vector256<ushort>.Count))) 280private static Vector256<byte> GetComparisonResult(ref char searchSpace, nuint ch2ByteOffset, nuint ch3ByteOffset, Vector256<ushort> ch1, Vector256<ushort> ch2, Vector256<ushort> ch3) 286Vector256<ushort> cmpCh1 = Vector256.Equals(ch1, Vector256.LoadUnsafe(ref searchSpace)); 287Vector256<ushort> cmpCh2 = Vector256.Equals(ch2, Vector256.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch2ByteOffset).AsUInt16()); 288Vector256<ushort> cmpCh3 = Vector256.Equals(ch3, Vector256.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch3ByteOffset).AsUInt16()); 293Vector256<ushort> caseConversion = Vector256.Create(CaseConversionMask); 295Vector256<ushort> cmpCh1 = Vector256.Equals(ch1, Vector256.LoadUnsafe(ref searchSpace) & caseConversion); 296Vector256<ushort> cmpCh2 = Vector256.Equals(ch2, Vector256.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch2ByteOffset).AsUInt16() & caseConversion); 297Vector256<ushort> cmpCh3 = Vector256.Equals(ch3, Vector256.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch3ByteOffset).AsUInt16() & caseConversion);
src\runtime\src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Byte.cs (48)
127else if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector256<byte>.Count >= 0) 136Vector256<byte> ch1 = Vector256.Create(value); 137Vector256<byte> ch2 = Vector256.Create(ch2Val); 140searchSpaceMinusValueTailLength - (nint)Vector256<byte>.Count; 146Debug.Assert(offset + ch1ch2Distance + Vector256<byte>.Count <= searchSpaceLength); 148Vector256<byte> cmpCh2 = Vector256.Equals(ch2, Vector256.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance))); 149Vector256<byte> cmpCh1 = Vector256.Equals(ch1, Vector256.LoadUnsafe(ref searchSpace, (nuint)offset)); 150Vector256<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte(); 153if (cmpAnd != Vector256<byte>.Zero) 159offset += Vector256<byte>.Count; 346else if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector256<byte>.Count) 348offset = searchSpaceMinusValueTailLength - Vector256<byte>.Count; 357Vector256<byte> ch1 = Vector256.Create(value); 358Vector256<byte> ch2 = Vector256.Create(ch2Val); 361Vector256<byte> cmpCh1 = Vector256.Equals(ch1, Vector256.LoadUnsafe(ref searchSpace, (nuint)offset)); 362Vector256<byte> cmpCh2 = Vector256.Equals(ch2, Vector256.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance))); 363Vector256<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte(); 366if (cmpAnd != Vector256<byte>.Zero) 385offset -= Vector256<byte>.Count; 386if (offset == -Vector256<byte>.Count) 524if ((((nuint)(uint)searchSpace + offset) & (nuint)(Vector256<byte>.Count - 1)) != 0) 552Vector256<byte> search = Vector256.Load(searchSpace + offset); 555uint matches = Vector256.Equals(Vector256<byte>.Zero, search).ExtractMostSignificantBits(); 559offset += (nuint)Vector256<byte>.Count; 591Vector256<byte> search = Vector256.Load(searchSpace + offset); 594uint matches = Vector256.Equals(Vector256<byte>.Zero, search).ExtractMostSignificantBits(); 598offset += (nuint)Vector256<byte>.Count; 637if ((((nuint)(uint)searchSpace + offset) & (nuint)(Vector256<byte>.Count - 1)) != 0) 664Vector256<byte> search = Vector256.Load(searchSpace + offset); 665uint matches = Vector256.Equals(Vector256<byte>.Zero, search).ExtractMostSignificantBits(); 671offset += (nuint)Vector256<byte>.Count; 853else if (Vector256.IsHardwareAccelerated && length >= (nuint)Vector256<byte>.Count) 856nuint lengthToExamine = length - (nuint)Vector256<byte>.Count; 868offset += (nuint)Vector256<byte>.Count; 1019if (lengthToExamine >= (nuint)Vector256<byte>.Count) 1021lengthToExamine -= (nuint)Vector256<byte>.Count; 1033offset += (nuint)Vector256<byte>.Count; 1277private static Vector256<byte> LoadVector256(ref byte start, nuint offset) 1278=> Unsafe.ReadUnaligned<Vector256<byte>>(ref Unsafe.AddByteOffset(ref start, offset)); 1286=> (nuint)(uint)((length - (int)offset) & ~(Vector256<byte>.Count - 1)); 1344else if (Avx2.IsSupported && remainder >= (nint)(Vector256<byte>.Count * 1.5)) 1346Vector256<byte> reverseMask = Vector256.Create( 1350nint lastOffset = remainder - Vector256<byte>.Count; 1354Vector256<byte> tempFirst = Vector256.LoadUnsafe(ref buf, (nuint)offset); 1355Vector256<byte> tempLast = Vector256.LoadUnsafe(ref buf, (nuint)lastOffset); 1385offset += Vector256<byte>.Count; 1386lastOffset -= Vector256<byte>.Count; 1389remainder = lastOffset + Vector256<byte>.Count - offset;
src\runtime\src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Char.cs (46)
139else if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector256<ushort>.Count >= 0) 148Vector256<ushort> ch1 = Vector256.Create((ushort)valueHead); 149Vector256<ushort> ch2 = Vector256.Create(ch2Val); 152searchSpaceMinusValueTailLength - (nint)Vector256<ushort>.Count; 157Debug.Assert(offset + ch1ch2Distance + Vector256<ushort>.Count <= searchSpaceLength); 159Vector256<ushort> cmpCh2 = Vector256.Equals(ch2, Vector256.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance))); 160Vector256<ushort> cmpCh1 = Vector256.Equals(ch1, Vector256.LoadUnsafe(ref searchSpace, (nuint)offset)); 161Vector256<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte(); 164if (cmpAnd != Vector256<byte>.Zero) 170offset += Vector256<ushort>.Count; 364else if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector256<ushort>.Count) 366offset = searchSpaceMinusValueTailLength - Vector256<ushort>.Count; 375Vector256<ushort> ch1 = Vector256.Create((ushort)valueHead); 376Vector256<ushort> ch2 = Vector256.Create((ushort)ch2Val); 381Vector256<ushort> cmpCh1 = Vector256.Equals(ch1, Vector256.LoadUnsafe(ref searchSpace, (nuint)offset)); 382Vector256<ushort> cmpCh2 = Vector256.Equals(ch2, Vector256.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance))); 383Vector256<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte(); 386if (cmpAnd != Vector256<byte>.Zero) 406offset -= Vector256<ushort>.Count; 407if (offset == -Vector256<ushort>.Count) 587if (((nint)(searchSpace + (nint)offset) & (nint)(Vector256<byte>.Count - 1)) != 0) 626Vector256<ushort> search = *(Vector256<ushort>*)(searchSpace + (nuint)offset); 629uint matches = Vector256.Equals(Vector256<ushort>.Zero, search).AsByte().ExtractMostSignificantBits(); 633offset += Vector256<ushort>.Count; 676Debug.Assert(lengthToExamine >= Vector256<ushort>.Count); 678Vector256<ushort> search = *(Vector256<ushort>*)(searchSpace + (nuint)offset); 681uint matches = Vector256.Equals(Vector256<ushort>.Zero, search).AsByte().ExtractMostSignificantBits(); 685offset += Vector256<ushort>.Count; 731if (((nint)(searchSpace + (nint)offset) & (nint)(Vector256<byte>.Count - 1)) != 0) 764Debug.Assert(lengthToExamine >= Vector256<ushort>.Count); 766Vector256<ushort> search = *(Vector256<ushort>*)(searchSpace + (nuint)offset); 767uint matches = Vector256.Equals(Vector256<ushort>.Zero, search).AsByte().ExtractMostSignificantBits(); 773offset += Vector256<ushort>.Count; 774lengthToExamine -= Vector256<ushort>.Count; 875=> (length - offset) & ~(Vector256<ushort>.Count - 1); 930else if (Avx2.IsSupported && remainder >= (nint)(Vector256<ushort>.Count * 1.5)) 932Vector256<byte> reverseMask = Vector256.Create( 936nint lastOffset = remainder - Vector256<ushort>.Count; 942Vector256<byte> tempFirst = Vector256.LoadUnsafe(ref first); 943Vector256<byte> tempLast = Vector256.LoadUnsafe(ref last); 967offset += Vector256<ushort>.Count; 968lastOffset -= Vector256<ushort>.Count; 971remainder = (lastOffset + Vector256<ushort>.Count - offset);
src\runtime\src\libraries\System.Private.CoreLib\src\System\SpanHelpers.cs (14)
125else if (Avx2.IsSupported && remainder >= Vector256<int>.Count * 2) 127nint lastOffset = remainder - Vector256<int>.Count; 131Vector256<int> tempFirst = Vector256.LoadUnsafe(ref buf, (nuint)offset); 132Vector256<int> tempLast = Vector256.LoadUnsafe(ref buf, (nuint)lastOffset); 149offset += Vector256<int>.Count; 150lastOffset -= Vector256<int>.Count; 153remainder = lastOffset + Vector256<int>.Count - offset; 230else if (Avx2.IsSupported && remainder >= Vector256<long>.Count * 2) 232nint lastOffset = remainder - Vector256<long>.Count; 236Vector256<long> tempFirst = Vector256.LoadUnsafe(ref buf, (nuint)offset); 237Vector256<long> tempLast = Vector256.LoadUnsafe(ref buf, (nuint)lastOffset); 254offset += Vector256<long>.Count; 255lastOffset -= Vector256<long>.Count; 258remainder = lastOffset + Vector256<long>.Count - offset;
src\runtime\src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Packed.cs (106)
198else if (Avx2.IsSupported && length > Vector256<short>.Count) 201Vector256<byte> packedValue = Vector256.Create((byte)value); 203if (length > 2 * Vector256<short>.Count) 209ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count)); 213Vector256<short> source0 = Vector256.LoadUnsafe(ref currentSearchSpace); 214Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 215Vector256<byte> packedSource = PackSources(source0, source1); 216Vector256<byte> result = Vector256.Equals(packedValue, packedSource); 218if (result != Vector256<byte>.Zero) 223currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count); 231ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count); 237Vector256<short> source0 = Vector256.LoadUnsafe(ref firstVector); 238Vector256<short> source1 = Vector256.LoadUnsafe(ref oneVectorAwayFromEnd); 239Vector256<byte> packedSource = PackSources(source0, source1); 240Vector256<byte> result = Vector256.Equals(packedValue, packedSource); 242if (result != Vector256<byte>.Zero) 397else if (Avx2.IsSupported && length > Vector256<short>.Count) 400Vector256<byte> packedValue = Vector256.Create((byte)value); 402if (length > 2 * Vector256<short>.Count) 408ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count)); 412Vector256<short> source0 = Vector256.LoadUnsafe(ref currentSearchSpace); 413Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 414Vector256<byte> packedSource = TTransform.TransformInput(PackSources(source0, source1)); 415Vector256<byte> result = Vector256.Equals(packedValue, packedSource); 418if (result != Vector256<byte>.Zero) 423currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count); 431ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count); 437Vector256<short> source0 = Vector256.LoadUnsafe(ref firstVector); 438Vector256<short> source1 = Vector256.LoadUnsafe(ref oneVectorAwayFromEnd); 439Vector256<byte> packedSource = TTransform.TransformInput(PackSources(source0, source1)); 440Vector256<byte> result = Vector256.Equals(packedValue, packedSource); 443if (result != Vector256<byte>.Zero) 609else if (Avx2.IsSupported && length > Vector256<short>.Count) 612Vector256<byte> packedValue0 = Vector256.Create((byte)value0); 613Vector256<byte> packedValue1 = Vector256.Create((byte)value1); 615if (length > 2 * Vector256<short>.Count) 621ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count)); 625Vector256<short> source0 = Vector256.LoadUnsafe(ref currentSearchSpace); 626Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 627Vector256<byte> packedSource = TTransform.TransformInput(PackSources(source0, source1)); 628Vector256<byte> result = Vector256.Equals(packedValue0, packedSource) | Vector256.Equals(packedValue1, packedSource); 631if (result != Vector256<byte>.Zero) 636currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count); 644ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count); 650Vector256<short> source0 = Vector256.LoadUnsafe(ref firstVector); 651Vector256<short> source1 = Vector256.LoadUnsafe(ref oneVectorAwayFromEnd); 652Vector256<byte> packedSource = TTransform.TransformInput(PackSources(source0, source1)); 653Vector256<byte> result = Vector256.Equals(packedValue0, packedSource) | Vector256.Equals(packedValue1, packedSource); 656if (result != Vector256<byte>.Zero) 825else if (Avx2.IsSupported && length > Vector256<short>.Count) 828Vector256<byte> packedValue0 = Vector256.Create((byte)value0); 829Vector256<byte> packedValue1 = Vector256.Create((byte)value1); 830Vector256<byte> packedValue2 = Vector256.Create((byte)value2); 832if (length > 2 * Vector256<short>.Count) 838ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count)); 842Vector256<short> source0 = Vector256.LoadUnsafe(ref currentSearchSpace); 843Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 844Vector256<byte> packedSource = PackSources(source0, source1); 845Vector256<byte> result = Vector256.Equals(packedValue0, packedSource) | Vector256.Equals(packedValue1, packedSource) | Vector256.Equals(packedValue2, packedSource); 848if (result != Vector256<byte>.Zero) 853currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count); 861ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count); 867Vector256<short> source0 = Vector256.LoadUnsafe(ref firstVector); 868Vector256<short> source1 = Vector256.LoadUnsafe(ref oneVectorAwayFromEnd); 869Vector256<byte> packedSource = PackSources(source0, source1); 870Vector256<byte> result = Vector256.Equals(packedValue0, packedSource) | Vector256.Equals(packedValue1, packedSource) | Vector256.Equals(packedValue2, packedSource); 873if (result != Vector256<byte>.Zero) 1022else if (Avx2.IsSupported && length > Vector256<short>.Count) 1025Vector256<byte> lowVector = Vector256.Create((byte)lowInclusive); 1026Vector256<byte> rangeVector = Vector256.Create((byte)rangeInclusive); 1028if (length > 2 * Vector256<short>.Count) 1034ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count)); 1038Vector256<short> source0 = Vector256.LoadUnsafe(ref currentSearchSpace); 1039Vector256<short> source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256<short>.Count); 1040Vector256<byte> packedSource = PackSources(source0, source1); 1041Vector256<byte> result = Vector256.LessThanOrEqual(packedSource - lowVector, rangeVector); 1044if (result != Vector256<byte>.Zero) 1049currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count); 1057ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count); 1063Vector256<short> source0 = Vector256.LoadUnsafe(ref firstVector); 1064Vector256<short> source1 = Vector256.LoadUnsafe(ref oneVectorAwayFromEnd); 1065Vector256<byte> packedSource = PackSources(source0, source1); 1066Vector256<byte> result = Vector256.LessThanOrEqual(packedSource - lowVector, rangeVector); 1069if (result != Vector256<byte>.Zero) 1155internal static Vector256<byte> PackSources(Vector256<short> source0, Vector256<short> source1) 1188private static Vector256<byte> NegateIfNeeded<TNegator>(Vector256<byte> result) 1239private static int ComputeFirstIndex(ref short searchSpace, ref short current, Vector256<byte> equals) 1271private static int ComputeFirstIndexOverlapped(ref short searchSpace, ref short current0, ref short current1, Vector256<byte> equals) 1275if (offsetInVector >= Vector256<short>.Count) 1279offsetInVector -= Vector256<short>.Count; 1301internal static Vector256<byte> FixUpPackedVector256Result(Vector256<byte> result) 1325static abstract Vector256<byte> TransformInput(Vector256<byte> input); 1333public static Vector256<byte> TransformInput(Vector256<byte> input) => input; 1341public static Vector256<byte> TransformInput(Vector256<byte> input) => input | Vector256.Create((byte)0x20);
src\runtime\src\libraries\System.Private.CoreLib\src\System\SpanHelpers.T.cs (103)
94vector = Vector512.Create(Unsafe.BitCast<T, Vector256<byte>>(value)).AsVector(); 1558else if (Vector256.IsHardwareAccelerated && length >= Vector256<T>.Count) 1560Vector256<T> equals, values = Vector256.Create(value); 1562ref T oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector256<T>.Count)); 1568if (equals == Vector256<T>.Zero) 1570currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<T>.Count); 1579if ((uint)length % Vector256<T>.Count != 0) 1582if (equals != Vector256<T>.Zero) 1777else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 1779Vector256<TValue> equals, values = Vector256.Create(value); 1781ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<TValue>.Count); 1787if (equals == Vector256<TValue>.Zero) 1789currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count); 1798if ((uint)length % Vector256<TValue>.Count != 0) 1801if (equals != Vector256<TValue>.Zero) 2041else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 2043Vector256<TValue> equals, current, values0 = Vector256.Create(value0), values1 = Vector256.Create(value1); 2045ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<TValue>.Count); 2052if (equals == Vector256<TValue>.Zero) 2054currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count); 2063if ((uint)length % Vector256<TValue>.Count != 0) 2067if (equals != Vector256<TValue>.Zero) 2282else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 2284Vector256<TValue> equals, current, values0 = Vector256.Create(value0), values1 = Vector256.Create(value1), values2 = Vector256.Create(value2); 2286ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<TValue>.Count); 2293if (equals == Vector256<TValue>.Zero) 2295currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count); 2304if ((uint)length % Vector256<TValue>.Count != 0) 2308if (equals != Vector256<TValue>.Zero) 2451else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 2453Vector256<TValue> equals, current, values0 = Vector256.Create(value0), values1 = Vector256.Create(value1), values2 = Vector256.Create(value2), values3 = Vector256.Create(value3); 2455ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<TValue>.Count); 2463if (equals == Vector256<TValue>.Zero) 2465currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count); 2474if ((uint)length % Vector256<TValue>.Count != 0) 2479if (equals != Vector256<TValue>.Zero) 2625else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 2627Vector256<TValue> equals, current, values0 = Vector256.Create(value0), values1 = Vector256.Create(value1), 2630ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector256<TValue>.Count)); 2638if (equals == Vector256<TValue>.Zero) 2640currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count); 2649if ((uint)length % Vector256<TValue>.Count != 0) 2654if (equals != Vector256<TValue>.Zero) 2800else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 2802return SimdImpl<Vector256<TValue>>(ref searchSpace, value, length); 2999else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 3001Vector256<TValue> equals, current, values0 = Vector256.Create(value0), values1 = Vector256.Create(value1); 3002nint offset = length - Vector256<TValue>.Count; 3010if (equals == Vector256<TValue>.Zero) 3012offset -= Vector256<TValue>.Count; 3024if (equals != Vector256<TValue>.Zero) 3215else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 3217Vector256<TValue> equals, current, values0 = Vector256.Create(value0), values1 = Vector256.Create(value1), values2 = Vector256.Create(value2); 3218nint offset = length - Vector256<TValue>.Count; 3226if (equals == Vector256<TValue>.Zero) 3228offset -= Vector256<TValue>.Count; 3239if (equals != Vector256<TValue>.Zero) 3373else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 3375Vector256<TValue> equals, current, values0 = Vector256.Create(value0), values1 = Vector256.Create(value1), values2 = Vector256.Create(value2), values3 = Vector256.Create(value3); 3376nint offset = length - Vector256<TValue>.Count; 3384if (equals == Vector256<TValue>.Zero) 3386offset -= Vector256<TValue>.Count; 3396if (equals != Vector256<TValue>.Zero) 3470if (!Vector256.IsHardwareAccelerated || length < (uint)Vector256<T>.Count) 3500nuint lastVectorIndex = length - (uint)Vector256<T>.Count; 3501Vector256<T> oldValues = Vector256.Create(oldValue); 3502Vector256<T> newValues = Vector256.Create(newValue); 3503Vector256<T> original, mask, result; 3512idx += (uint)Vector256<T>.Count; 3645else if (Vector256.IsHardwareAccelerated && length >= Vector256<TValue>.Count) 3647Vector256<TValue> equals, current, values0 = Vector256.Create(value0), values1 = Vector256.Create(value1), 3649nint offset = length - Vector256<TValue>.Count; 3657if (equals == Vector256<TValue>.Zero) 3659offset -= Vector256<TValue>.Count; 3671if (equals != Vector256<TValue>.Zero) 3722private static unsafe int ComputeFirstIndex<T>(ref T searchSpace, ref T current, Vector256<T> equals) where T : struct 3746private static int ComputeLastIndex<T>(nint offset, Vector256<T> equals) where T : struct 3765static abstract Vector256<T> NegateIfNeeded(Vector256<T> equals); 3783public static Vector256<T> NegateIfNeeded(Vector256<T> equals) => equals; 3807public static Vector256<T> NegateIfNeeded(Vector256<T> equals) => ~equals; 3901else if (!Vector256.IsHardwareAccelerated || length < Vector256<T>.Count) 3932Vector256<T> lowVector = Vector256.Create(lowInclusive); 3933Vector256<T> rangeVector = Vector256.Create(highInclusive - lowInclusive); 3934Vector256<T> inRangeVector; 3937ref T oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector256<T>.Count)); 3943if (inRangeVector != Vector256<T>.Zero) 3948current = ref Unsafe.Add(ref current, Vector256<T>.Count); 3954if (inRangeVector != Vector256<T>.Zero) 4048else if (!Vector256.IsHardwareAccelerated || length < Vector256<T>.Count) 4077Vector256<T> lowVector = Vector256.Create(lowInclusive); 4078Vector256<T> rangeVector = Vector256.Create(highInclusive - lowInclusive); 4079Vector256<T> inRangeVector; 4081nint offset = length - Vector256<T>.Count; 4087if (inRangeVector != Vector256<T>.Zero) 4092offset -= Vector256<T>.Count; 4097if (inRangeVector != Vector256<T>.Zero) 4188else if (Vector256.IsHardwareAccelerated && length >= Vector256<T>.Count) 4190Vector256<T> targetVector = Vector256.Create(value); 4191ref T oneVectorAwayFromEnd = ref Unsafe.Subtract(ref end, Vector256<T>.Count); 4195current = ref Unsafe.Add(ref current, Vector256<T>.Count);
src\runtime\src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (33)
1326else if (Vector256.IsHardwareAccelerated && length >= (uint)Vector256<ushort>.Count) 1328nuint adjust = (length - remainingLength) & ((uint)Vector256<ushort>.Count - 1); 2222else if (Vector256.IsHardwareAccelerated && (uint)remaining.Length >= (uint)Vector256<ushort>.Count*2) 2224Vector256<ushort> v1 = Vector256.Create((ushort)c); 2225Vector256<ushort> v2 = Vector256.Create((ushort)c2); 2226Vector256<ushort> v3 = Vector256.Create((ushort)c3); 2234Vector256<byte> packedComparand1 = Vector256.Create((byte)c); 2235Vector256<byte> packedComparand2 = Vector256.Create((byte)c2); 2236Vector256<byte> packedComparand3 = Vector256.Create((byte)c3); 2237while ((uint)remaining.Length >= (uint)Vector256<ushort>.Count*2) 2239Vector256<ushort> vector1 = Vector256.Create(remaining); 2240Vector256<ushort> vector2 = Vector256.Create(remaining.Slice(Vector256<ushort>.Count)); 2241var packed = PackedSpanHelpers.PackSources(vector1.AsInt16(), vector2.AsInt16()); 2243if ((Vector256.Equals(packed, packedComparand1) | Vector256.Equals(packed, packedComparand2) | Vector256.Equals(packed, packedComparand3)) != Vector256<byte>.Zero) 2245var cmp1 = Vector256.Equals(vector1, v1).AsByte() | Vector256.Equals(vector1, v2).AsByte() | Vector256.Equals(vector1, v3).AsByte(); 2246var cmp2 = Vector256.Equals(vector2, v1).AsByte() | Vector256.Equals(vector2, v2).AsByte() | Vector256.Equals(vector2, v3).AsByte(); 2261sepListBuilder.Append(baseIndex + (int)bitPos + Vector256<ushort>.Count); 2268baseIndex += Vector256<ushort>.Count*2; 2269remaining = remaining.Slice(Vector256<ushort>.Count*2); 2274baseIndex += Vector256<ushort>.Count*2; 2275remaining = remaining.Slice(Vector256<ushort>.Count*2); 2279while ((uint)remaining.Length >= (uint)Vector256<ushort>.Count) 2281Vector256<ushort> vector = Vector256.Create(remaining); 2282Vector256<byte> cmp = Vector256.Equals(vector, v1).AsByte() | Vector256.Equals(vector, v2).AsByte() | Vector256.Equals(vector, v3).AsByte(); 2284if (cmp != Vector256<byte>.Zero) 2296baseIndex += Vector256<ushort>.Count; 2297remaining = remaining.Slice(Vector256<ushort>.Count); 2304Vector256<ushort> vector = Vector256.Create(sourceSpanUInt16.Slice(sourceSpanUInt16.Length - Vector256<ushort>.Count)); 2305Vector256<byte> cmp = Vector256.Equals(vector, v1).AsByte() | Vector256.Equals(vector, v2).AsByte() | Vector256.Equals(vector, v3).AsByte(); 2306int finalIndex = sourceSpanUInt16.Length - Vector256<ushort>.Count; 2307uint mask = cmp.ExtractMostSignificantBits() & 0x55555555 & ~((1u << (Vector256<byte>.Count - remaining.Length * sizeof(char))) - 1);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Ascii.CaseConversion.cs (1)
482Vector256<ushort> wide = Vector256.WidenLower(vector.AsByte().ToVector256Unsafe());
src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Ascii.cs (17)
119if (length <= 2 * Vector256<T>.Count) 123Vector256.LoadUnsafe(ref Unsafe.Subtract(ref searchSpaceEnd, Vector256<T>.Count))); 127if (length > 4 * Vector256<T>.Count) 132Vector256.LoadUnsafe(ref searchSpace, (nuint)Vector256<T>.Count) | 133Vector256.LoadUnsafe(ref searchSpace, 2 * (nuint)Vector256<T>.Count) | 134Vector256.LoadUnsafe(ref searchSpace, 3 * (nuint)Vector256<T>.Count))) 139nuint i = 4 * (nuint)Vector256<T>.Count; 144nuint misalignedElements = Unsafe.OpportunisticMisalignment(ref searchSpace, (uint)Vector256<byte>.Count) / (nuint)sizeof(T); 146Debug.Assert((int)i > 3 * Vector256<T>.Count); 148nuint finalStart = (nuint)length - 4 * (nuint)Vector256<T>.Count; 150for (; i < finalStart; i += 4 * (nuint)Vector256<T>.Count) 156Vector256.LoadUnsafe(ref current, (nuint)Vector256<T>.Count) | 157Vector256.LoadUnsafe(ref current, 2 * (nuint)Vector256<T>.Count) | 158Vector256.LoadUnsafe(ref current, 3 * (nuint)Vector256<T>.Count))) 172Vector256.LoadUnsafe(ref searchSpace, (nuint)Vector256<T>.Count) | 173Vector256.LoadUnsafe(ref Unsafe.Subtract(ref searchSpaceEnd, 2 * Vector256<T>.Count)) | 174Vector256.LoadUnsafe(ref Unsafe.Subtract(ref searchSpaceEnd, Vector256<T>.Count)));
src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Equality.cs (39)
95else if (Avx.IsSupported && length >= (uint)Vector256<TLeft>.Count) 101Debug.Assert(Vector256<TLeft>.Count == Vector256<TRight>.Count 102|| (typeof(TLoader) == typeof(WideningLoader) && Vector256<TLeft>.Count == Vector256<TRight>.Count * 2)); 103ref TRight oneVectorAwayFromRightEnd = ref Unsafe.Add(ref currentRightSearchSpace, length - (uint)Vector256<TLeft>.Count); 113currentRightSearchSpace = ref Unsafe.Add(ref currentRightSearchSpace, Vector256<TLeft>.Count); 114currentLeftSearchSpace = ref Unsafe.Add(ref currentLeftSearchSpace, Vector256<TLeft>.Count); 119if (length % (uint)Vector256<TLeft>.Count != 0) 121ref TLeft oneVectorAwayFromLeftEnd = ref Unsafe.Add(ref left, length - (uint)Vector256<TLeft>.Count); 306else if (Avx.IsSupported && length >= (uint)Vector256<TRight>.Count) 309ref TLeft oneVectorAwayFromLeftEnd = ref Unsafe.Add(ref currentLeftSearchSpace, length - (uint)Vector256<TRight>.Count); 311ref TRight oneVectorAwayFromRightEnd = ref Unsafe.Add(ref currentRightSearchSpace, length - (uint)Vector256<TRight>.Count); 313Vector256<TRight> leftValues; 314Vector256<TRight> rightValues; 316Vector256<TRight> loweringMask = Vector256.Create(TRight.CreateTruncating(0x20)); 317Vector256<TRight> vecA = Vector256.Create(TRight.CreateTruncating('a')); 318Vector256<TRight> vecZMinusA = Vector256.Create(TRight.CreateTruncating(('z' - 'a'))); 331Vector256<TRight> notEquals = ~Vector256.Equals(leftValues, rightValues); 333if (notEquals != Vector256<TRight>.Zero) 346currentRightSearchSpace = ref Unsafe.Add(ref currentRightSearchSpace, (uint)Vector256<TRight>.Count); 347currentLeftSearchSpace = ref Unsafe.Add(ref currentLeftSearchSpace, (uint)Vector256<TRight>.Count); 352if (length % (uint)Vector256<TRight>.Count != 0) 362Vector256<TRight> notEquals = ~Vector256.Equals(leftValues, rightValues); 364if (notEquals != Vector256<TRight>.Zero) 460static abstract Vector256<TRight> Load256(ref TLeft ptr); 469public static Vector256<T> Load256(ref T ptr) => Vector256.LoadUnsafe(ref ptr); 476Vector256<T> leftValues = Vector256.LoadUnsafe(ref left); 477Vector256<T> rightValues = Vector256.LoadUnsafe(ref right); 529public static Vector256<ushort> Load256(ref byte ptr) 546Debug.Assert(Vector256<byte>.Count == Vector256<ushort>.Count * 2); 548Vector256<byte> leftNotWidened = Vector256.LoadUnsafe(ref utf8); 554(Vector256<ushort> leftLower, Vector256<ushort> leftUpper) = Vector256.Widen(leftNotWidened); 555Vector256<ushort> right = Vector256.LoadUnsafe(ref utf16); 556Vector256<ushort> rightNext = Vector256.LoadUnsafe(ref utf16, (uint)Vector256<ushort>.Count); 559if (((leftLower ^ right) | (leftUpper ^ rightNext)) != Vector256<ushort>.Zero)
src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Utility.cs (23)
180else if (Vector256.IsHardwareAccelerated && bufferLength >= 2 * (uint)Vector256<byte>.Count) 803else if (Vector256.IsHardwareAccelerated && bufferLength >= 2 * (uint)Vector256<ushort>.Count) 1381else if (Vector256.IsHardwareAccelerated && elementCount >= 2 * (uint)Vector256<byte>.Count) 1584internal static bool VectorContainsNonAsciiChar(Vector256<ushort> utf16Vector) 1587Vector256<ushort> zeroIsAscii = utf16Vector & Vector256.Create(asciiMask); 1589return zeroIsAscii != Vector256<ushort>.Zero; 1637private static bool AllCharsInVectorAreAscii<T>(Vector256<T> vector) 1645Avx.IsSupported ? (vector.AsByte() & Vector256.Create((byte)0x80)) == Vector256<byte>.Zero: 1650return (vector.AsUInt16() & Vector256.Create((ushort)0xFF80)) == Vector256<ushort>.Zero; 1696internal static Vector256<byte> ExtractAsciiVector(Vector256<ushort> vectorFirst, Vector256<ushort> vectorSecond) 1850Vector256<ushort> utf16VectorFirst = Vector256.LoadUnsafe(ref utf16Buffer); 1861Vector256<byte> asciiVector = ExtractAsciiVector(utf16VectorFirst, utf16VectorFirst); 1906Vector256<ushort> utf16VectorSecond = Vector256.LoadUnsafe(ref utf16Buffer, currentOffsetInElements + Vector256.Size / sizeof(short)); 1907Vector256<ushort> combinedVector = utf16VectorFirst | utf16VectorSecond; 2084else if (Vector256.IsHardwareAccelerated && (elementCount - currentOffset) >= (uint)Vector256<byte>.Count) 2086WidenAsciiToUtf1_Vector<Vector256<byte>, Vector256<ushort>>(pAsciiBuffer, pUtf16Buffer, ref currentOffset, elementCount); 2254if (typeof(TVectorByte) == typeof(Vector256<byte>)) 2256(Vector256<ushort> Lower256, Vector256<ushort> Upper256) = Vector256.Widen((Vector256<byte>)(object)vector);
src\runtime\src\libraries\System.Private.CoreLib\src\System\ThrowHelper.cs (1)
829if (!Vector256<T>.IsSupported)
System.Runtime.Intrinsics (1)
src\runtime\artifacts\obj\System.Runtime.Intrinsics\Release\net11.0\System.Runtime.Intrinsics.Forwards.cs (1)
22[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.Intrinsics.Vector256<>))]
System.Runtime.Numerics (16)
System\Numerics\BigIntegerCalculator.ShiftRot.cs (13)
172while (Vector256.IsHardwareAccelerated && offset >= Vector256<nuint>.Count + 1) 174Vector256<nuint> current = Vector256.LoadUnsafe(ref start, (nuint)(offset - Vector256<nuint>.Count)) << shift; 175Vector256<nuint> carries = Vector256.LoadUnsafe(ref start, (nuint)(offset - (Vector256<nuint>.Count + 1))) >> back; 177Vector256<nuint> newValue = current | carries; 179Vector256.StoreUnsafe(newValue, ref start, (nuint)(offset - Vector256<nuint>.Count)); 180offset -= Vector256<nuint>.Count; 241while (Vector256.IsHardwareAccelerated && remaining.Length >= Vector256<nuint>.Count + 1) 243Vector256<nuint> current = Vector256.Create(remaining) >> shift; 244Vector256<nuint> carries = Vector256.Create(remaining.Slice(1)) << back; 246Vector256<nuint> newValue = current | carries; 249remaining = remaining.Slice(Vector256<nuint>.Count);
System\Numerics\NumericsHelpers.cs (3)
87while (Vector256.IsHardwareAccelerated && d.Length >= Vector256<nuint>.Count) 89Vector256<nuint> complement = ~Vector256.Create(d); 91d = d.Slice(Vector256<nuint>.Count);