using System.Runtime.Intrinsics;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
[MemoryDiagnoser]
public class SimdBenchmark
{
    private float[] _arrA;
    private float[] _arrB;
    private float[] _resultArray;
    private readonly int _dataSize = 1_000_000;
    [GlobalSetup]
    public void Setup()
    {
        var random = new Random();
        _arrA = new float[_dataSize];
        _arrB = new float[_dataSize];
        _resultArray = new float[_dataSize];
        for (int i = 0; i < _dataSize; i++)
        {
            _arrA[i] = (float)random.NextDouble() * 10f;
            _arrB[i] = (float)random.NextDouble() * 10f;
        }
    }
    [Benchmark]
    public void NormalAdd()
    {
        for (int i = 0; i < _dataSize; i++)
        {
            _resultArray[i] = _arrA[i] + _arrB[i];
        }
    }
    [Benchmark]
    public void SimdAdd()
    {
        // 每次處理 4 個(gè)元素
        int simdLength = Vector128<float>.Count; // 4
        int i = 0;
        // 處理可被 SIMD 整除的部分
        for (; i <= _dataSize - simdLength; i += simdLength)
        {
            var va = Vector128.Create(_arrA[i], _arrA[i + 1], _arrA[i + 2], _arrA[i + 3]);
            var vb = Vector128.Create(_arrB[i], _arrB[i + 1], _arrB[i + 2], _arrB[i + 3]);
            (va + vb).CopyTo(_resultArray, i);
        }
        // 處理尾部不足 4 個(gè)的元素
        for (; i < _dataSize; i++)
        {
            _resultArray[i] = _arrA[i] + _arrB[i];
        }
    }
}
public class Program
{
    public static void Main(string[] args)
    {
        BenchmarkRunner.Run<SimdBenchmark>();
    }
}

BenchmarkDotNet v0.15.6, macOS Sequoia 15.7.2 (24G325) [Darwin 24.6.0]
Apple M2 Max, 1 CPU, 12 logical and 12 physical cores
.NET SDK 9.0.100
  [Host]     : .NET 9.0.0 (9.0.0, 9.0.24.52809), Arm64 RyuJIT armv8.0-a
  DefaultJob : .NET 9.0.0 (9.0.0, 9.0.24.52809), Arm64 RyuJIT armv8.0-a
| Method    | Mean     | Error   | StdDev  | Allocated |
|---------- |---------:|--------:|--------:|----------:|
| NormalAdd | 880.4 us | 9.28 us | 7.75 us |         - |
| SimdAdd   | 568.5 us | 4.18 us | 3.70 us |         - |

using System.Runtime.Intrinsics;
// 創(chuàng)建一個(gè) 128 位的向量，存儲(chǔ) 16 個(gè) 8 位的 字節(jié)
Vector128<byte> vectorByte = Vector128.Create((byte)1, (byte)2, (byte)3, (byte)4,
                                               (byte)5, (byte)6, (byte)7, (byte)8,
                                               (byte)9, (byte)10, (byte)11, (byte)12,
                                               (byte)13, (byte)14, (byte)15, (byte)16);
// 創(chuàng)建一個(gè) 128 位的向量，存儲(chǔ) 4 個(gè) 32 位的 浮點(diǎn)數(shù)
Vector128<float> vectorFloat = Vector128.Create(1.0f, 2.0f, 3.0f, 4.0f);
// 創(chuàng)建一個(gè) 256 位的向量，存儲(chǔ) 8 個(gè) 32 位的 浮點(diǎn)數(shù)
Vector256<float> vector256Float = Vector256.Create(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
// 創(chuàng)建一個(gè) 128 位的向量，存儲(chǔ) 2 個(gè) 64 位的 雙精度浮點(diǎn)數(shù)
Vector128<double> vectorDouble = Vector128.Create(1.0, 2.0);
// 創(chuàng)建一個(gè) 256 位的向量，存儲(chǔ) 4 個(gè) 64 位的 雙精度浮點(diǎn)數(shù)
Vector256<double> vector256Double = Vector256.Create(1.0, 2.0, 3.0, 4.0);

Console.WriteLine(Vector128.IsHardwareAccelerated ? "128 位向量操作受支持" : "128 位向量操作不受支持");

using System.Runtime.Intrinsics;
// 創(chuàng)建兩個(gè) 128 位的浮點(diǎn)向量
Vector128<float> vectorA = Vector128.Create(1.0f, 2.0f, 3.0f, 4.0f);
Vector128<float> vectorB = Vector128.Create(5.0f, 6.0f, 7.0f, 8.0f);
// 執(zhí)行加法運(yùn)算
// 等效于 vectorA + vectorB
var result = Vector128.Add(vectorA, vectorB);
// 輸出結(jié)果
Console.WriteLine($"Result: {result}");

Result: <6, 8, 10, 12>

using System.Runtime.Intrinsics.X86;
Console.WriteLine(Sse.IsSupported ? "SSE 指令集受支持" : "SSE 指令集不受支持");

using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;
if (Sse.IsSupported)
{
    // 創(chuàng)建兩個(gè) 128 位的浮點(diǎn)向量
    Vector128<float> vectorA = Vector128.Create(1.0f, 2.0f, 3.0f, 4.0f);
    Vector128<float> vectorB = Vector128.Create(5.0f, 6.0f, 7.0f, 8.0f);
    // 使用 SSE 指令集執(zhí)行加法運(yùn)算
    var result = Sse.Add(vectorA, vectorB);
    // 輸出結(jié)果
    Console.WriteLine($"Result: {result}");
}
else
{
    Console.WriteLine("SSE 指令集不受支持");
}

Result: <6, 8, 10, 12>

using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
if (AdvSimd.IsSupported)
{
    // 創(chuàng)建兩個(gè) 128 位的浮點(diǎn)向量
    Vector128<float> vectorA = Vector128.Create(1.0f, 2.0f, 3.0f, 4.0f);
    Vector128<float> vectorB = Vector128.Create(5.0f, 6.0f, 7.0f, 8.0f);
    // 使用 AdvSimd 指令集執(zhí)行加法運(yùn)算
    var result = AdvSimd.Add(vectorA, vectorB);
    // 輸出結(jié)果
    Console.WriteLine($"Result: {result}");
}
else
{
    Console.WriteLine("AdvSimd 指令集不受支持");
}

Result: <6, 8, 10, 12>

var vectorSize = Vector<float>.Count; // 獲取向量大?。ㄔ貍€(gè)數(shù)）
float[] arrayA = new float[1000];
float[] arrayB = new float[1000];
float[] resultArray = new float[1000];
for (int i = 0; i <= arrayA.Length - vectorSize; i += vectorSize)
{
    var va = new Vector<float>(arrayA, i);
    var vb = new Vector<float>(arrayB, i);
    (va + vb).CopyTo(resultArray, i);
}

using System.Numerics;
// 創(chuàng)建 Vector3 實(shí)例
Vector3 vector1 = new Vector3(1.0f, 2.0f, 3.0f);
Vector3 vector2 = new Vector3(4.0f, 5.0f, 6.0f);
// 向量加法
Vector3 resultAdd = Vector3.Add(vector1, vector2);
Console.WriteLine($"Addition: {resultAdd}"); // 輸出: <5, 7, 9>
// 向量點(diǎn)乘
float dotProduct = Vector3.Dot(vector1, vector2);
Console.WriteLine($"Dot Product: {dotProduct}"); // 輸出: 32
// 向量歸一化
Vector3 normalized = Vector3.Normalize(vector1);
Console.WriteLine($"Normalized: {normalized}"); // 輸出: <0.2672612, 0.5345225, 0.8017837>

public struct Vector3 : IEquatable<Vector3>, IFormattable
{
    /// <summary>The X component of the vector.</summary>
    public float X;
    /// <summary>The Y component of the vector.</summary>
    public float Y;
    /// <summary>The Z component of the vector.</summary>
    public float Z;
    public Vector3(float x, float y, float z) => this = Vector3.Create(x, y, z);
    public static Vector3 Create(float x, float y, float z)
    {
        return Vector128.Create(x, y, z, 0.0f).AsVector3();
    }
    // 省略其他成員...
}

using System.Numerics;
// 創(chuàng)建一個(gè) 4x4 矩陣
Matrix4x4 matrix = Matrix4x4.CreateRotationX((float)(Math.PI / 4));
Vector3 point = new Vector3(1.0f, 0.0f, 0.0f);
// 使用矩陣變換點(diǎn)
Vector3 transformedPoint = Vector3.Transform(point, matrix);
Console.WriteLine($"Transformed Point: {transformedPoint}");

Transformed Point: <1, 0, 0>

Console.WriteLine((char)('a' ^ 0x20)); // 輸出 A
Console.WriteLine((char)('A' ^ 0x20)); // 輸出 a

public static class Ascii
{
    public static OperationStatus ToUpper(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten);
    public static OperationStatus ToLower(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten);
    public static OperationStatus ToUpperInPlace(Span<byte> value, out int bytesWritten);
    public static OperationStatus ToLowerInPlace(Span<byte> value, out int bytesWritten);
    public static OperationStatus ToUpper(ReadOnlySpan<char> source, Span<char> destination, out int charsWritten);
    public static OperationStatus ToLower(ReadOnlySpan<char> source, Span<char> destination, out int charsWritten);
    public static OperationStatus ToUpperInPlace(Span<char> value, out int charsWritten);
    public static OperationStatus ToLowerInPlace(Span<char> value, out int charsWritten);
}
public enum OperationStatus
{
    /// <summary>The entire input buffer has been processed and the operation is complete.</summary>
    Done,
    /// <summary>The input is partially processed, up to what could fit into the destination buffer. The caller can enlarge the destination buffer, slice the buffers appropriately, and retry.</summary>
    DestinationTooSmall,
    /// <summary>The input is partially processed, up to the last valid chunk of the input that could be consumed. The caller can stitch the remaining unprocessed input with more data, slice the buffers appropriately, and retry.</summary>
    NeedMoreData,
    /// <summary>The input contained invalid bytes which could not be processed. If the input is partially processed, the destination contains the partial result. This guarantees that no additional data appended to the input will make the invalid sequence valid.</summary>
    InvalidData,
}

void ToUpperInPlace(Span<char> value)
{
    // 將 Span<char> 轉(zhuǎn)換成 Span<ushort>（char 占 2 字節(jié)，方便 SIMD 處理）
    var buffer = MemoryMarshal.Cast<char, ushort>(value);
    // 獲取元素?cái)?shù)量（ushort 數(shù)量）
    var elementCount = (uint)buffer.Length;
    // 每個(gè)向量能處理多少個(gè) ushort
    var numElementsPerVector = (uint)(Unsafe.SizeOf<Vector128<byte>>() / sizeof(ushort));
    // 如果支持 SIMD 且數(shù)據(jù)足夠，否則走普通循環(huán)
    if (Vector128.IsHardwareAccelerated && elementCount >= numElementsPerVector)
    {
        // 有符號(hào)最小值 (0x8000) 用于偏移正確比較
        ushort sourceSignedMinValue = (ushort)(1 << (8 * sizeof(ushort) - 1));
        // 'a' 的基準(zhǔn)向量（所有元素都是 0x8000 + 'a'）
        var subtractionVector = Vector128.Create((ushort)(sourceSignedMinValue + 'a'));
        // 26 個(gè)字母范圍偏移向量（所有元素都是 0x8000 + 26）
        var comparisonVector = Vector128.Create((ushort)(sourceSignedMinValue + 26));
        // 大小寫差值向量（0x20，所有元素都是這個(gè)值）
        var caseConversionVector = Vector128.Create((ushort)0x20);
        // 向量化循環(huán)索引
        uint i = 0;
        // 可以整除的元素個(gè)數(shù)
        uint n = elementCount - (elementCount % numElementsPerVector);
        // 向量化批量處理
        for (; i < n; i += numElementsPerVector)
        {
            // 加載當(dāng)前批次的向量數(shù)據(jù)
            var srcVector = Vector128.LoadUnsafe(ref Unsafe.Add(ref MemoryMarshal.GetReference(buffer), (int)i));
            // 計(jì)算 src - 'a' 基準(zhǔn)，并判斷是否小于 26（即在 a..z 范圍）
            var matches = SignedLessThan(srcVector - subtractionVector, comparisonVector);
            // 對(duì)匹配的小寫字母執(zhí)行大小寫轉(zhuǎn)換（異或 0x20 得到大寫）
            srcVector ^= matches & caseConversionVector;
            // 存回修改后的向量數(shù)據(jù)
            srcVector.StoreUnsafe(ref Unsafe.Add(ref MemoryMarshal.GetReference(buffer), (int)i));
        }
        // 處理剩余不足一個(gè)向量大小的元素
        for (; i < elementCount; i++)
        {
            // 讀取當(dāng)前字符
            ushort c = Unsafe.Add(ref MemoryMarshal.GetReference(buffer), (int)i);
            // 如果是小寫字母則轉(zhuǎn)為大寫
            if (c is >= 'a' and <= 'z')
            {
                c = (ushort)(c - 0x20);
            }
            // 寫回結(jié)果
            Unsafe.Add(ref MemoryMarshal.GetReference(buffer), (int)i) = c;
        }
    }
    else
    {
        // 非向量化處理，每個(gè)元素單獨(dú)判斷
        for (int i = 0; i < buffer.Length; i++)
        {
            ushort c = buffer[i];
            if (c is >= 'a' and <= 'z')
            {
                c = (ushort)(c - 0x20);
            }
            buffer[i] = c;
        }
    }
}
// 有符號(hào)比較（用于判斷 a..z 范圍）
Vector128<ushort> SignedLessThan(Vector128<ushort> left, Vector128<ushort> right)
{
    // 將 ushort 當(dāng)成 short 做有符號(hào)比較，然后再轉(zhuǎn)換回 ushort 掩碼
    return Vector128.LessThan(left.AsInt16(), right.AsInt16()).AsInt16().AsUInt16();
}

string input = "Hello World! This is a Test String.";
Span<char> span = input.ToCharArray();
ToUpperInPlace(span);
string result = new string(span);
Console.WriteLine(result); // 輸出: "HELLO WORLD! THIS IS A TEST STRING."

using System.Text;
string input = "Hello World! This is a Test String. 這部分不會(huì)被轉(zhuǎn)換。";
Span<char> span = input.ToCharArray();
Ascii.ToUpperInPlace(span, out int charsWritten);
// charsWritten 表示實(shí)際轉(zhuǎn)換的字符數(shù)，非 ASCII 字符不會(huì)被轉(zhuǎn)換
string result = new string(span[..charsWritten]);
Console.WriteLine(result); // 輸出: "HELLO WORLD! THIS IS A TEST STRING."

Span<ushort> data = [0x1234, 0xABCD, 0x5678, 0xEF01];
Span<ushort> reversedData = stackalloc ushort[4];
BinaryPrimitives.ReverseEndianness(data, reversedData);
foreach (var value in reversedData)
{
    Console.WriteLine(value.ToString("X4"));
}

3412
CDAB
7856
01EF