C#实现递归；二维数组的转置；矩阵的相乘（介绍利用Parallel.For 循环并行计算解决传统for循环慢的问题）；值和矩阵相乘；求矩阵的逆

一、递归实现二阶差分

递归就是方法调用它自身，并且可读性很好，缺点就是一般不是最快的实现。
初学者在用递归实现方法是，常见的错误在程序执行期间发生栈溢出，这是由无限递归造成；或者你返回的不是你想要的。
以下就是靠递归来实现一个二阶差分

private void Form1_Load(object sender, EventArgs e)
 {           
    double[,] array = new double[,] { { 1,1, 1 }, { 5, 5, 5 }, { 25, 25, 25 } };//定义一个3行3列的二维数组     
    column = array.GetLength(0);//获得列数
    double[,] temp = returndiff(array);
}
 private static double[,] returndiff(double[,] inputd)
 {
     numt += 1;//numt是全局变量，你自己定义
     int row = inputd.GetUpperBound(0);//因为差分一次行数少一
     double[,] temparray = new double[row, column];
     //开始差分
     for (int i = 0; i < row; i++)
     {
        for (int j = 0; j < column; j++)
        {
            emparray[i, j] = inputd[i + 1, j] - inputd[i, j];
        }
     }
     if (numt==1)
     {
          return returndiff(temparray);//在return里面用递归，这样子写很关键//1//4
     }               
            
      return temparray;//2
}//3//5

在代码中执行到2的时候，已经把你的数组传回去了，结果是[16 16 16]。

二、矩阵转置

        private static double[,] transpose(double[,] inpute)
        {
            int x = inpute.GetUpperBound(0) + 1;//获得行数
            int y = inpute.GetUpperBound(1) + 1;//获得列数
            double[,] transarray = new double[y, x];
            for (int i = 0; i < x; i++)
            {
                for (int j = 0; j < y; j++)
                {
                    transarray[j, i] = inpute[i, j];
                }
            }
            return transarray;
        }

三、矩阵的相乘

        private static double[,] arrMultiply(double[,] input1, double[,] input2)
        {
           int input1x = input1.GetUpperBound(0) + 1;//获得行数900
            int input1y = input1.GetUpperBound(1) + 1;//获得列数898
            int input2x = input2.GetUpperBound(0) + 1;//获得行数898
            int input2y = input2.GetUpperBound(1) + 1;//获得列数900
            double tempvale = 0;
            double[,] retarr = new double[input1x, input2y];
            //Parallel.For(0, input1x, k =>//可以用这个来解决运算慢的问题
            //{
            //    for (int i = 0; i < input2y; i++)
            //    {
            //        for (int j = 0; j < input2x; j++)
            //        {
            //            tempvale += input1[k, j] * input2[j, i];
            //        }
            //        retarr[k, i] = tempvale;
            //        tempvale = 0;
            //    }
            //});
            for (int k = 0; k < input1x; k++)
            {
                for (int i = 0; i < input2y; i++)
                {
                    for (int j = 0; j < input2x; j++)
                    {
                        tempvale += input1[k, j] * input2[j, i];
                    }
                    retarr[k, i] = tempvale;
                    tempvale = 0;
                }
            }
            return retarr;
        }

四、值和矩阵相乘

        /// <summary>
        /// 值和矩阵相乘
        /// </summary>
        /// <param name="input1"></param>
        /// <param name="input2"></param>
        /// <returns></returns>
        private static double[,] valueArrMultiply(double input1, double[,] input2)
        {
            int input2x = input2.GetUpperBound(0) + 1;//获得行数
            int input2y = input2.GetLength(0);//获得列数
            double[,] arraytempdd = new double[input2x, input2y];
            for(int i=0;i< input2x;i++)
            {
                for(int j=0;j< input2y;j++)
                {
                    arraytempdd[i, j] = input1* input2[i, j];
                }
            }
            return arraytempdd;
        }

五、求矩阵的逆

public static double[,] Inverse(double[,] Array)
        {
            int m = 0;
            int n = 0;
            m = Array.GetLength(0);
            n = Array.GetLength(1);
            double[,] array = new double[2 * m + 1, 2 * n + 1];
            for (int k = 0; k < 2 * m + 1; k++)  //初始化数组
            {
                for (int t = 0; t < 2 * n + 1; t++)
                {
                    array[k, t] = 0.00000000;
                }
            }
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    array[i, j] = Array[i, j];
                }
            }

            for (int k = 0; k < m; k++)
            {
                for (int t = n; t <= 2 * n; t++)
                {
                    if ((t - k) == m)
                    {
                        array[k, t] = 1.0;
                    }
                    else
                    {
                        array[k, t] = 0;
                    }
                }
            }
            //得到逆矩阵
            for (int k = 0; k < m; k++)
            {
                if (array[k, k] != 1)
                {
                    double bs = array[k, k];
                    array[k, k] = 1;
                    for (int p = k + 1; p < 2 * n; p++)
                    {
                        array[k, p] /= bs;
                    }
                }
                for (int q = 0; q < m; q++)
                {
                    if (q != k)
                    {
                        double bs = array[q, k];
                        for (int p = 0; p < 2 * n; p++)
                        {
                            array[q, p] -= bs * array[k, p];
                        }
                    }
                    else
                    {
                        continue;
                    }
                }
            }
            double[,] NI = new double[m, n];
            for (int x = 0; x < m; x++)
            {
                for (int y = n; y < 2 * n; y++)
                {
                    NI[x, y - n] = array[x, y];
                }
            }
            return NI;
        }

各位需要注意，如果你的数据集非常大，使用传统的for循环会非常耗时，建议你利用矩阵来计算，比利用C#代码快很多倍（实测，利用实现相同的算法矩阵快了4.5倍），你可以查看我的其他博客https://blog.csdn.net/weixin_42974146/article/details/106424862