C# 列主元素（Gauss）消去法 计算一元多次方程组

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace zblGauss1
{
    class Program
    {
        static void Main(string[] args)
        {
            //double[,] a = { { 8.1, 2.3, -1.5, 6.1 }, { 0.5, -6.23, 0.87, 2.3 }, { 2.5, 1.5, 10.2, 1.8 } };
            //double[,] a = { { 2, -1, 3, 1 }, { 4, 2, 5, 4 }, { 1, 2, 0, 7 } };
            double[,] a = { { 0.01200, 0.01000, 0.1670, 0.6781 }, { 1.000, 0.8334, 5.910, 12.10 }, { 3200, 1200, 4.200, 981.0 } };
            int n = a.GetLength(0);//数组a的第一维长度，即行数,3
            double[] x = new double[n];//存放解的数组，初始值为0

            // Gauss1(n, a, x);//调用Gauss1 方法计算,用顺序高斯消去法计算一元多次方程组
            Gauss2(n, a, x);//列主元Gauss消去法
            Console.WriteLine("方程的{0}个根为：",n);//输出方程组的根
            for (int i = 0; i < n; i++)
            {
                Console.Write("x{0}={1,10:F10}, ", i+1, x[i]);
            }
        }

        //利用顺序高斯Gauss消元法求一元多次线性方程组的解
        public static void Gauss1(int n, double[,] a, double[] x)//写了一个静态方法，方法可以在别的方法中直接调用，不必声明对象然后调用对象中的方法了
        {
            Console.WriteLine("-----------利用顺序高斯Gauss消元法求线性方程组的解----------");
            Console.WriteLine("要计算的增广矩阵a为：");
            printArray(n, a);

            //消元过程
            for (int k = 0; k < n - 1; k++)//k=0 1 ，弄出来两个主元即可 ,两次大循环，此称为1层循环  ---主元---
            {
                for (int i = k; i < n - 1; i++)//每个大循环中   要对主元素下面所有元素变化为零,，  ---行---  ，i= 0 1 ，此称为2层循环
                {
                    double m = a[i + 1, k] / a[k, k];//可能用到多次，在此将化零因子放入m中
                    for (int j = k; j <= n; j++) //2层循环中要对每行所有元素都做相同变化，   ---列---    ，  j=
                    {
                        a[i + 1, j] = a[i + 1, j] - m * a[k, j];//由于第一行第一列元素不用化零，故首先从i+1开始，同列所以后面都是j，k处为主元行处
                    }
                    Console.WriteLine("第{0}个主元第{1}次变换后增广矩阵为：", k, i);
                    printArray(n, a);
                }
                Console.WriteLine();
            }

            //回代过程
            for (int k = n - 1; k >= 0; k--) //k=2 1 0 从最后一行开始往前迭代
            {
                double addResult = 0.0;//用于存放已知的未知数代入相应式子中之和，换一行计算时需要清零，故放在此处
                for (int j = k; j < n - 1; j++)//j=2   j 最大值为2，每行未知数可能不止一个，故需要遍历已知的未知数并代入
                {
                    addResult = addResult + x[j + 1] * a[k, j + 1];//k代表计算的行，j+1代表的列，系数与解要对应，故都为 j+1
                }
                x[k] = (a[k, n] - addResult) / a[k, k];//本行的未知数用本行最右边数-本行已知未知数代入系数之差 再除以本未知数系数
            }

        }

        public static void Gauss2(int n, double[,] a, double[] x)//写了一个静态方法，方法可以在别的方法中直接调用，不必声明对象然后调用对象中的方法了
        {
            Console.WriteLine("-----------利用顺序高斯Gauss消元法求线性方程组的解----------");
            Console.WriteLine("要计算的增广矩阵a为：");
            printArray(n, a);

            //消元过程
            for (int k = 0; k < n - 1; k++)//k=0 1 ，弄出来两个主元即可 ,两次大循环，此称为1层循环  ---主元---
            {
                selectMainElement(n, k, a); // 选择主元素  
                Console.WriteLine("------------第{0}个主元选择主元素后的增广矩阵为：---------------",k,a);
                printArray(n, a);
                Console.WriteLine();
                for (int i = k; i < n - 1; i++)//每个大循环中   要对主元素下面所有元素变化为零,，  ---行---  ，i= 0 1 ，此称为2层循环
                {
                    double m = a[i + 1, k] / a[k, k];//可能用到多次，在此将化零因子放入m中
                    for (int j = k; j <= n; j++) //2层循环中要对每行所有元素都做相同变化，   ---列---    ，  j=
                    {
                        a[i + 1, j] = a[i + 1, j] - m * a[k, j];//由于第一行第一列元素不用化零，故首先从i+1开始，同列所以后面都是j，k处为主元行处
                    }
                    Console.WriteLine("第{0}个主元第{1}次变换后增广矩阵为：", k, i);
                    printArray(n, a);
                }
                Console.WriteLine();
            }

            //回代过程
            for (int k = n - 1; k >= 0; k--) //k=2 1 0 从最后一行开始往前迭代
            {
                double addResult = 0.0;//用于存放已知的未知数代入相应式子中之和，换一行计算时需要清零，故放在此处
                for (int j = k; j < n - 1; j++)//j=2   j 最大值为2，每行未知数可能不止一个，故需要遍历已知的未知数并代入
                {
                    addResult = addResult + x[j + 1] * a[k, j + 1];//k代表计算的行，j+1代表的列，系数与解要对应，故都为 j+1
                }
                x[k] = (a[k, n] - addResult) / a[k, k];//本行的未知数用本行最右边数-本行已知未知数代入系数之差 再除以本未知数系数
            }

        }
        public static void printArray(int n, double[,] a)
        {
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j <= n; j++)
                {
                    Console.Write("{0,15:F6}", a[i, j]);
                }
                Console.WriteLine();
            }
        }

        /// <summary>
        /// selectMainElement 用来选择出第k个主元及其所在列下面所有元素中最大的元素作为主元
        /// </summary>
        /// <param name="n">传递过来的矩阵a的行数</param>
        /// <param name="k">现在主元所在行数</param>
        /// <param name="a">传递过来的用来处理的矩阵</param>
        public static void selectMainElement(int n, int k, double[,] a)
        {
            double t, mainElement;// mainElement用于保存主元素的值
            int l;// 用于保存主元素所在的行号
            mainElement = Math.Abs(a[k, k]);  // 注意别忘了取绝对值  
            // 从第k行到第n行寻找第k列的主元素，记下主元素mainElement和所在的行号l  
            l = k;
            for (int i = k + 1; i < n; i++)
            {
                if (mainElement < Math.Abs(a[i, k]))
                {
                    mainElement = Math.Abs(a[i, k]);
                    l = i;                        // 记下主元素所在的行号  
                }
            }
            // l是主元素所在的行。将l行与k行交换，每行前面的k个元素都是0，不必交换  
            if (l != k)
            {
                for (int j = k; j <= n; j++)
                {
                    t = a[k, j]; a[k, j] = a[l, j]; a[l, j] = t;
                }
            }
        }


    }
}

方法是在第k次消元之前，先对增广矩阵作第一种初等行变换，目的是把此主元所在列中找到包括主元在内及其下面元素中最大值作为新的主元，新主元与原先主元所在行交换，然后再用消去法，然后再计算。