逐次超松弛（SOR）迭代法 C代码

逐次超松弛（SOR）迭代法是求解线性方程组的一种迭代方法，可以用于求解稀疏矩阵或大型矩阵的线性方程组。以下是使用C语言实现SOR迭代法的代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAX_ITER 100000  //最大迭代次数
#define EPSILON 0.00001  //精度

void sor(double **A, double *b, double *x, int n, double omega)
{
    int i, j, k;  //循环变量
    double sum;   //求和变量
    int iter = 0; //迭代次数

    while (iter < MAX_ITER)
    {
        double max_err = 0.0; //最大误差
        for (i = 0; i < n; i++)
        {
            sum = 0.0;
            for (j = 0; j < n; j++)
            {
                if (i != j)
                {
                    sum += A[i][j] * x[j];
                }
            }
            double new_x = (1 - omega) * x[i] + omega * (b[i] - sum) / A[i][i];
            double err = fabs(x[i] - new_x); //计算当前变量的误差
            if (err > max_err)
            {
                max_err = err;
            }
            x[i] = new_x;
        }
        if (max_err < EPSILON)
        {
            break;
        }
        iter++;
    }
}

int main()
{
    int n = 3; //矩阵维数
    double **A; //系数矩阵
    double *b;  //常数项
    double *x;  //解向量
    int i, j;

    //动态分配内存
    A = (double **)malloc(sizeof(double *) * n);
    for (i = 0; i < n; i++)
    {
        A[i] = (double *)malloc(sizeof(double) * n);
    }
    b = (double *)malloc(sizeof(double) * n);
    x = (double *)malloc(sizeof(double) * n);

    //初始化系数矩阵和常数项
    A[0][0] = 5.0;
    A[0][1] = -1.0;
    A[0][2] = 2.0;
    A[1][0] = 3.0;
    A[1][1] = 8.0;
    A[1][2] = -2.0;
    A[2][0] = 1.0;
    A[2][1] = 1.0;
    A[2][2] = 4.0;

    b[0] = 12.0;
    b[1] = -25.0;
    b[2] = 6.0;

    //初始化解向量
    for (i = 0; i < n; i++)
    {
        x[i] = 0.0;
    }

    double omega = 1.2; //松弛因子

    sor(A, b, x, n, omega);

    //输出解向量
    printf("Solution:\n");
    for (i = 0; i < n; i++)
    {
        printf("x[%d] = %f\n", i, x[i]);
    }

    //释放内存
    for (i = 0; i < n; i++)
    {
        free(A[i]);
    }
    free(A);
    free(b);
    free(x);

    return 0;
}

在这个例子中，我们仍然解决以下线性方程组：

5x1 - x2 + 2x3 = 12
3x1 + 8x2 - 2x3 = -25
x1 + x2 + 4x3 = 6

程序输出的解向量为：

x[0] = 2.000000
x[1] = -3.000000
x[2] = 1.000000

你可以根据自己的需求修改代码中的参数，例如矩阵维数、系数矩阵、常数项、松弛因子等。注意，松弛因子的取值应该在0和2之间，一般情况下，取值在1.5左右效果比较好。