C#，码海拾贝（23）——线性方程组求解的复系数方程组的全选主元高斯消去法之C#源代码，《C#数值计算算法编程》源代码升级改进版

以下是使用C#实现全选主元高斯消去法求解复系数方程组的代码示例：

csharp
using System;

namespace LinearEquationSolver
{
    class Program
    {
        static void Main(string[] args)
        {
            // 定义复系数方程组的系数矩阵和常数向量
            Complex[] coefficients = new Complex[]
            {
                { new Complex(2 1) new Complex(3 -2) new Complex(1 3) }
                { new Complex(1 -1) new Complex(2 2) new Complex(3 -1) }
                { new Complex(3 2) new Complex(1 1) new Complex(2 -2) }
            };

            Complex[] constants = new Complex[]
            {
                new Complex(4 3)
                new Complex(2 -1)
                new Complex(1 2)
            };

            // 求解方程组
            Complex[] solutions = SolveLinearEquations(coefficients constants);

            // 输出结果
            Console.WriteLine(Solution:);
            for (int i = 0; i < solutions.Length; i++)
            {
                Console.WriteLine($x{i + 1} = {solutions[i]});
            }
        }

        static Complex[] SolveLinearEquations(Complex[] coefficients Complex[] constants)
        {
            int n = constants.Length;
            Complex[] solutions = new Complex[n];

            // 高斯消去法
            for (int k = 0; k < n - 1; k++)
            {
                // 选取主元
                int pivotRow = k;
                int pivotColumn = k;
                Complex pivotValue = coefficients[k k];

                for (int i = k; i < n; i++)
                {
                    for (int j = k; j < n; j++)
                    {
                        if (coefficients[i j].Magnitude > pivotValue.Magnitude)
                        {
                            pivotRow = i;
                            pivotColumn = j;
                            pivotValue = coefficients[i j];
                        }
                    }
                }

                // 交换行
                if (pivotRow != k)
                {
                    for (int j = k; j < n; j++)
                    {
                        Complex temp = coefficients[k j];
                        coefficients[k j] = coefficients[pivotRow j];
                        coefficients[pivotRow j] = temp;
                    }

                    Complex tempConstant = constants[k];
                    constants[k] = constants[pivotRow];
                    constants[pivotRow] = tempConstant;
                }

                // 交换列
                if (pivotColumn != k)
                {
                    for (int i = 0; i < n; i++)
                    {
                        Complex temp = coefficients[i k];
                        coefficients[i k] = coefficients[i pivotColumn];
                        coefficients[i pivotColumn] = temp;
                    }
                }

                // 消元
                for (int i = k + 1; i < n; i++)
                {
                    Complex factor = coefficients[i k] / coefficients[k k];
                    constants[i] -= factor * constants[k];

                    for (int j = k; j < n; j++)
                    {
                        coefficients[i j] -= factor * coefficients[k j];
                    }
                }
            }

            // 回代求解
            solutions[n - 1] = constants[n - 1] / coefficients[n - 1 n - 1];

            for (int i = n - 2; i >= 0; i--)
            {
                Complex sum = constants[i];

                for (int j = i + 1; j < n; j++)
                {
                    sum -= coefficients[i j] * solutions[j];
                }

                solutions[i] = sum / coefficients[i i];
            }

            return solutions;
        }
    }

    // 复数类
    class Complex
    {
        public double Real { get; set; }
        public double Imaginary { get; set; }

        public Complex(double real double imaginary)
        {
            Real = real;
            Imaginary = imaginary;
        }

        public double Magnitude
        {
            get { return Math.Sqrt(Real * Real + Imaginary * Imaginary); }
        }

        public static Complex operator +(Complex a Complex b)
        {
            return new Complex(a.Real + b.Real a.Imaginary + b.Imaginary);
        }

        public static Complex operator -(Complex a Complex b)
        {
            return new Complex(a.Real - b.Real a.Imaginary - b.Imaginary);
        }

        public static Complex operator *(Complex a Complex b)
        {
            double real = a.Real * b.Real - a.Imaginary * b.Imaginary;
            double imaginary = a.Real * b.Imaginary + a.Imaginary * b.Real;
            return new Complex(real imaginary);
        }

        public static Complex operator /(Complex a Complex b)
        {
            double denominator = b.Real * b.Real + b.Imaginary * b.Imaginary;
            double real = (a.Real * b.Real + a.Imaginary * b.Imaginary) / denominator;
            double imaginary = (a.Imaginary * b.Real - a.Real * b.Imaginary) / denominator;
            return new Complex(real imaginary);
        }

        public override string ToString()
        {
            return ${Real} + {Imaginary}i;
        }
    }
}