LU分解算法的C语言实现（数值分析经典算法）

算法理论

$A=LU$分解算法：
$1.u_{1i}=a_{1i},(i=1,2,\cdots ,n);l_{i1}=a_{i1}/u_{11},(i=2,3,\cdots ,n)$
计算$U$的第$r$行，$L$的第$r$列元素$(r=2,3,\cdots ,n)$:
$2.u_{ri}=a_{ri}-{\sum }_{k=1}^{r-1}{l}_{rk}{u}_{kr},(i=r,r+1,\cdots ,n)$
$3.l_{ir}=(a_{ir}-{\sum }_{k=1}^{r-1}{l}_{ik}{u}_{kr})/u_{rr},(i=r+1,\cdots ,n,且r̸=n)$
求解$Ly=b,Ux=y$的计算公式：
$4.y1=b1;y_i=b_i-{\sum }_{k=1}^{i-1}{l}_{ik}{y}_k,(i=2,3,\cdots ,n)$
$5.x_n=y_n/u_{nn};x_i=(y_i-{\sum }_{k=i+1}^n{u}_{ik}{x}_k)/u_{ii},(i=n-1,n-2,\cdots ,1)$
其中值得注意的是：LU分解所用到的数学知识很基础并没有太大难度，只不过是矩阵乘法的知识以及两个矩阵相等时其对应元素也相等的知识。

算法对应的实验要求

实验要求

用LU分解算法求解给定的线性方程组$Ax=b$，其中函数接口定义为：

bool Direct( int n, double a[][MAX_SIZE], double b[] )

在$Direct$的接口定义中，$n$为矩阵$a$的维数，MAX_SIZE是由裁判程序定义的矩阵最大维数，$b$是方程组中的常向量，求得的解将存储在$b$中返回。本题目要求先用杜利特尔分解，再求解两个三角型方程组。函数返回布尔型值，当求解成功时返回TRUE，否则返回FALSE。
其中裁判程序的主函数为：

int main()
{
  int n, i, j;
  double a[MAX_SIZE][MAX_SIZE], b[MAX_SIZE];
  while ( scanf("%d", &n) != EOF ) { /* 读取裁判测试用例 */
    for ( i=0; i<n; i++ ) {
      for ( j=0; j<n; j++ )
        scanf("%lf", &a[i][j]);
      scanf("%lf", &b[i]);
    }
    /*--- 输出直接法的解 ---*/
    if ( Direct(n, a, b) ) {
      printf("Result of direct method:\n");
      for ( j=0; j<n; j++ )
        printf("%.8lf\n", b[j]);
    }
    else
      printf("Doolittle factorization failed.\n");
    printf("\n");
  }
  return 0;
}

实验要求解析

$LU$分解实验中最重要的函数为$Direct$函数，下面将给出实现$Direct$函数的步骤。

Step1：定义变量

由于$Direct$函数返回$bool$值，所以首先定义一个$bool$类型的变量“$flag$”并初始化为$true$，作为判断矩阵A是否能进行$LU$分解的标志；其次，由于对$A$进行$LU$分解的矩阵$L$为单位下三角矩阵，$U$为上三角矩阵，所以LU可以同时存在并覆盖原始的A矩阵，故无需创建新的矩阵$L$和$U$；最后需建立一个$double$类型的y数组存放$Ly=b$中$y$的值。

Step2：对L矩阵的第一列进行先赋值

由于后续的计算需要用到L矩阵的第一列，故需先进行赋值；而由于U矩阵的第一行与A矩阵的第一行相同，故可以不做赋值处理。

Step3：对U的第r行和L的第r列进行赋值(r=2,3,…,n)

此处的赋值操作与“算法理论”部分介绍的思想一致。

Step4：判断矩阵A是否能进行LU分解

由于只有非奇异的矩阵$A$才能进行$LU$分解，但在实验过程中，计算矩阵$A$的行列式是否非0或判断矩阵$A$的顺序主子式是否都大于0相对而言都比较困难，所以要采取其他方式进行判断。
在求解$l_{ir}$的过程中，由于
$l_{ir}=(a_{ir}-{\sum }_{k=1}^{r-1}{l}_{ik}{u}_{kr})/u_{rr},(i=r+1,\cdots ,n,且r̸=n)$
故只需最后对$u_{rr}$做出判断即可。当$u_{rr}=0$时将$flag$置为$false$，并直接返回$flag$，不再进行后续的“Step5”和“Step6”操作。

Step5：由Ly=b求解出y数组

Step6：由Ux=y求解出x数组

由于求解出的$x$，可以存储在b数组中，所以在“Step1：定义变量”中并未定义x数组，求出的解$x$即全部存储在b数组中。

代码实现

#include<stdio.h>
#include<math.h>
#include<stdbool.h>
#define MAX_SIZE 100 /* 矩阵最大维数 */
#define ZERO 0.000000001 /* 当一个正数小于ZERO就认为该数是0 */

bool Direct( int n, double a[][MAX_SIZE], double b[] )
{
    bool flag = true;
    double y[n];
    int r;
    int i;
    int k;
    double sum_u, sum_l;
    for(r=1;r<n;r++)
        a[r][0] = a[r][0]/a[0][0];
    for(r=1;r<n;r++)
    {
        for(i=r;i<n;i++)
        {
            sum_u = 0;
            for(k=0;k<r;k++)
                sum_u += a[r][k]*a[k][i];
            a[r][i] = a[r][i]-sum_u;
        }
        for(i=r+1;i<n&&r!=n-1;i++)
        {
            sum_l = 0;
            for(k=0;k<r;k++)
                sum_l += a[i][k]*a[k][r];
            a[i][r] = (a[i][r]-sum_l)/a[r][r];
        }
    }
    //--------------------------------------------------------------------------//
    for(r=0;r<n;r++)
    {
        if(a[r][r]==0) //等价于判断矩阵的顺序主子式是否为0
        {
            flag = false;
            return flag;
        }
    }
    //--------------------------------------------------------------------------//
    //--------------------------------------------------------------------------//
    y[0] = b[0];
    double sum;
    for(i=1;i<n;i++)
    {
        sum = 0;
        for(k=0;k<i;k++)
            sum += a[i][k]*y[k];
        y[i] = b[i]-sum;
    }
    //--------------------------------------------------------------------------//
    //--------------------------------------------------------------------------//
    b[n-1] = y[n-1]/a[n-1][n-1];
    for(i=n-2;i>=0;i--)
    {
        sum = 0;
        for(k=i+1;k<n;k++)
            sum += a[i][k]*b[k];
        b[i] = (y[i]-sum)/a[i][i];
    }
    return flag;
}



int main()
{
    int n, i, j;
    double a[MAX_SIZE][MAX_SIZE], b[MAX_SIZE];

    while ( scanf("%d", &n) != EOF ) { /* 读取裁判测试用例 */
        for ( i=0; i<n; i++ )
        {
            for ( j=0; j<n; j++ )
                scanf("%lf", &a[i][j]);
            scanf("%lf", &b[i]);
        }
    /*--- 输出直接法的解 ---*/
    if ( Direct(n, a, b) )
    {
        printf("Result of direct method:\n");
            for ( j=0; j<n; j++ )
                printf("%.8lf\n", b[j]);
    }
    else
        printf("Doolittle factorization failed.\n");
    printf("\n");
  }
  return 0;
}

输入输出检测

Input: 
6
4 -1 0 -1 0 0 0
-1 4 -1 0 -1 0 5
0 -1 4 0 0 -1 0
-1 0 0 4 -1 0 6
0 -1 0 -1 4 -1 -2
0 0 -1 0 -1 4 6
Output: 
Result of direct method:
1.00000000
2.00000000
1.00000000
2.00000000
1.00000000
2.00000000
//--------------------------------//
Input:
3
3 -1 0 1
3 6 0 0
3 3 0 4
Output:
Doolittle factorization failed.
//--------------------------------//
Input:
3
3 -1 3 1
3 6 3 0
3 3 3 4
Output:
Doolittle factorization failed.
//--------------------------------//
Input:
7
1.0 0.0 2.0 0.0 3.0 0.0 4.0 3
3.0 -1.0 0.5 8.0 2.2 1.6 0.0 8
0.0 0.0 0.0 4.5 3.2 2.0 1.0 2
2.0 3.0 5.0 0.0 0.0 0.0 2.0 4
-2.0 -3.0 1.0 1.0 0.0 0.0 3.3 1
2.5 4.5 0.0 0.0 1.0 0.0 0.0 -2
-0.5 -1.5 3.0 2.0 0.0 1.0 -1.0 5
Output:
Doolittle factorization failed.
//--------------------------------//
Input:
3
1.00000000 0.50000000 0.33333333 1.0
0.50000000 0.33333333 0.25000000 1.0
0.33333333 0.25000000 0.20000000 1.0
Output:
Result of direct method:
3.00000408
-24.00002076
30.00001920
//--------------------------------//
Input:
4
1.00000000 0.50000000 0.33333333 0.25000000 1.0
0.50000000 0.33333333 0.25000000 0.20000000 1.0
0.33333333 0.25000000 0.20000000 0.16666667 1.0
0.25000000 0.20000000 0.16666667 0.14285714 1.0
Output:
Result of direct method:
-4.00028881
60.00328814
-180.00799473
140.00523622
//--------------------------------//

欢迎批评指正！