C# 使用Vector256写了一个简单的帮助类Vector256Helper

 当数据量大的时候用普通代码计算非常耗时，这里简单利用simd加速处理

 internal unsafe class Vector256Helper
    {
        /// <summary>
        /// 统计元素个数
        /// </summary>
        /// <param name="array"></param>
        /// <param name="elementToCount">需要统计的元素</param>
        /// <returns></returns>
        public static int Count(int[] array, int elementToCount)
        {
            int count = 0;
            int vectorSize = Vector256<int>.Count;
            int limit = array.Length - (array.Length % vectorSize);
            fixed (int* pArray = array)
            {
                int* ptr = pArray;
                var target = Vector256.Create(elementToCount);
                Vector256<int> equalMask = Vector256<int>.Zero;
                for (int i = 0; i < limit; i += vectorSize)
                {
                    Vector256<int> vector = *(Vector256<int>*)(ptr + i);
                    equalMask += Avx2.CompareEqual(vector, target);
                }
                int* equalMaskPtr = (int*)&equalMask;
                for (int j = 0; j < vectorSize; j++)
                {
                    count += -*(equalMaskPtr + j);
                }
                // 处理剩余的元素
                for (int i = limit; i < array.Length; i++)
                {
                    if (*(pArray + i) == elementToCount)
                        count++;
                }
            }
            return count;
        }
        /// <summary>
        /// 求和
        /// </summary>
        /// <param name="buffer"></param>
        /// <returns></returns>
        public static int Sum(int[] buffer)
        {
           int vectorSize = Vector256<int>.Count;
            int sum4 = 0;
            Vector256<int> sumV = Vector256<int>.Zero;
            fixed (int* p = buffer)
            {
                for (int j = 0; j <= buffer.Length; j += vectorSize)
                {
                    sumV = Avx2.Add(sumV, *(Vector256<int>*)(p + j));
                }
                int* ptr = (int*)&sumV;
                for (int i = 0; i < vectorSize; i++)
                {
                    sum4 += *(ptr + i);
                }
            }
            return sum4;
        }
        /// <summary>
        /// 求平均数
        /// </summary>
        /// <param name="buffer"></param>
        /// <returns></returns>
        public double Avg(int[] buffer)
        {
            int sum = Sum(buffer);
            return sum / (double)buffer.Length;
        }
        /// <summary>
        /// 求最大值
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public static int Max(int[] array)
        {
            int vectorSize = Vector256<int>.Count;
            int limit = array.Length - (array.Length % vectorSize);

            fixed (int* pArray = array)
            {
                int maxElement = *pArray;
                Vector256<int> vectorMax = *(Vector256<int>*)(pArray);
                for (int i = 1; i < limit; i += vectorSize)
                {
                    Vector256<int> vector = *(Vector256<int>*)(pArray + i);
                    vectorMax = Avx2.Max(vectorMax, vector);
                }
                int* maxPtr = (int*)&vectorMax;
                for (int j = 0; j < vectorSize; j++)
                {
                    maxElement = Math.Max(maxElement, *(maxPtr + j));
                }
                for (int i = limit; i < array.Length; i++)
                {
                    maxElement = Math.Max(maxElement, *(pArray + i));
                }

                return maxElement;
            }
        }
        /// <summary>
        /// 求最小值
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public static int Min(int[] array)
        {
            int vectorSize = Vector256<int>.Count;
            int limit = array.Length - (array.Length % vectorSize);

            fixed (int* pArray = array)
            {
                int maxElement = *pArray;
                Vector256<int> vectorMin = *(Vector256<int>*)(pArray);
                for (int i = 1; i < limit; i += vectorSize)
                {
                    Vector256<int> vector = *(Vector256<int>*)(pArray + i);
                    vectorMin = Avx2.Min(vectorMin, vector);
                }
                int* maxPtr = (int*)&vectorMin;
                for (int j = 0; j < vectorSize; j++)
                {
                    maxElement = Math.Min(maxElement, *(maxPtr + j));
                }
                for (int i = limit; i < array.Length; i++)
                {
                    maxElement = Math.Min(maxElement, *(pArray + i));
                }

                return maxElement;
            }
        }
        /// <summary>
        /// 图像灰度化
        /// </summary>
        /// <param name="buffer"></param>
        /// <param name="width"></param>
        /// <param name="heigth"></param>
        private unsafe void Gray(byte[] buffer, int width, int heigth)
        {
            int size = heigth * width;
            int factor = buffer.Length / size;
            int vectorSize = Vector256<float>.Count;
            int step = factor * vectorSize;
            int n = buffer.Length / factor;
            fixed (byte* ptr = buffer)
            {
                byte* p = ptr;
                int k = 0;
                Vector256<float> r = new Vector256<float>();
                Vector256<float> g = new Vector256<float>();
                Vector256<float> b = new Vector256<float>();
                float* rPtr = (float*)&r;
                float* gPtr = (float*)&g;
                float* bPtr = (float*)&b;
                for (int i = 0; i <= buffer.Length; i += step)
                {
                    for (int j = 0; j < vectorSize; j++)
                    {
                        byte* val = ptr + i + j * factor;
                        *(bPtr + j) = *(val);
                        *(gPtr + j) = *(++val);
                        *(rPtr + j) = *(++val);
                    }
                    var rgbVector = Avx2.Add(Avx2.Add(Avx2.Multiply(r, RCoefficients), Avx2.Multiply(g, GCoefficients)), Avx2.Multiply(b, BCoefficients));
                    float* rgbPtr = (float*)&rgbVector;
                    for (int j = 0; j < vectorSize; j++)
                    {
                        byte* val = ptr + i + j * factor;
                        *val = *(val + 1) = *(val + 2) = (byte)(*(rgbPtr + j));
                    }
                }
            }
        }
        private unsafe void GrayMatrix(byte[] buffer, int width, int heigth)
        {
            int size = heigth * width;
            int factor = buffer.Length / size;
            int m = factor << 2;
            fixed (byte* ptr = buffer)
            {
                for (int i = 0; i < buffer.Length; i += m)
                {
                    byte* p = ptr + i;
                    Matrix4x4 matrix = new Matrix4x4(
                        (float)*(p), (float)*(p + 1), (float)*(p + 2), 0,
                        (float)*(p + 3), (float)*(p + 4), (float)*(p + 5), 0,
                        (float)*(p + 6), (float)*(p + 7), (float)*(p + 8), 0,
                        (float)*(p + 9), (float)*(p + 10), (float)*(p + 11), 0);

                    var mm = matrix * mCoe;
                    *p = *(p + 1) = *(p + 2) = (byte)mm.M11;
                    *(p + 3) = *(p + 4) = *(p + 5) = (byte)mm.M21;
                    *(p + 6) = *(p + 7) = *(p + 8) = (byte)mm.M31;
                    *(p + 9) = *(p + 10) = *(p + 11) = (byte)mm.M31;
                }
            }
        }
    }