计算方法 -- 解线性方程组直接法(LU分解、列主元高斯消元、追赶法)

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
using namespace std;
#define N 20

double A[N][N],L[N][N],U[N][N],b[N],Y[N],X[N];

/// -------------------------------------------------------------------------文件处理
void saveLU(int n)
{
    for(int i=; i<n; i++) {
        for(int j=; j<n; j++) {
            cout<<L[i][j]<<" ";
        }
        cout<<endl;
    }
    cout<<endl<<endl;
    for(int i=; i<n; i++) {
        for(int j=; j<n; j++) {
            cout<<U[i][j]<<" ";
        }
        cout<<endl;
    }
}

void saveT(double arr[], int n)
{
    for(int i=; i<n; i++) {
        cout<<arr[i]<<" ";
    }
    cout<<endl<<endl;
}

///-------------------------------------------------------------------------初始化
void init(int n)
{
    freopen("input.txt","r",stdin);
    freopen("lu.txt","w",stdout);
    for(int i=; i<n; i++) {
        for(int j=; j<n; j++) {
            cin>>A[i][j];
        }
    }
    for(int i=; i<n; i++) {
        cin>>b[i];
    }
}

///-------------------------------------------------------------------------直接法分解LU
void breakdown(int n)
{
    for (int i=; i<n; i++) {
        U[][i] = A[][i]; ///U 第一行
        L[i][] = A[i][]/U[][]; ///L 第一列
    }
    ///U 第R行 L 第R列
    double tmp = ;
    for (int r=; r<n; r++) {
        for (int i=r; i<n; i++) {
            tmp = A[r][i];
            for(int k=;k<=r-; k++) {
                tmp -= L[r][k]*U[k][i];
            }
            U[r][i] = tmp;
            tmp =A[i][r];
            for(int k=; k<=r-; k++) {
                tmp -= L[i][k]*U[k][r];
            }
            L[i][r] = tmp/U[r][r];
        }
    }

}

///-------------------------------------------------------------------------直接法计算Y
void computeY(int n)
{
    Y[]=b[]; ///自上往下
    for (int i=; i<n; i++) {
        Y[i] = b[i];
        for (int j=; j<=i-; j++) {
            Y[i] -= L[i][j]*Y[j];
        }
    }
}
///-------------------------------------------------------------------------直接法计算X
void computeX(int n)
{
    int con = n;
    n--;
    X[n] = Y[n]/U[n][n]; ///自下往上

    for (int i=n-; i>=; i--) {
        X[i] = Y[i];
        for (int k=i+; k<con; k++) {
            X[i] -= U[i][k]*X[k];
        }
        X[i]/=U[i][i];
    }
}

///追赶法解三对角矩阵方程组{1.三对角矩阵LU分解 2.求y 3.求x }
///-------------------------------------------------------------------------1. LU分解
void TriangleBreakdown(int n)
{
    for (int i=; i<n; i++) { /// L的下对角线 U的主对角线可直接得出
        U[i][i] = ;
        if(i+ < n)
            L[i+][i] = A[i+][i];
    }
    L[][] = A[][];
    U[][] = A[][]/L[][];
    for (int i=; i<n; i++) { ///L的下对角线  U的上对角线
        L[i][i] = A[i][i] - L[i][i-] * U[i-][i];
        if(i+ < n)
            U[i][i+] = A[i][i+]/L[i][i];
    }
}
///------------------------------------------------------------------------- 计算X
void TriangleY(int n)
{
    Y[] = b[]/A[][];
    for (int i=; i<n; i++) {
        Y[i] = (b[i]-A[i][i-]*Y[i-])/L[i][i];
    }
}
///-------------------------------------------------------------------------计算Y
void TriangleX(int n)
{
    X[n-] = Y[n-];
    for (int i=n-; i>=; i--) {
        X[i] = Y[i] - U[i][i+] * X[i+];
    }
}

///------------------------------------------------------三种方法整合
double AB[N][N+];
void swap_cols(int x, int y, int n) ///交换两行
{
    double tmp = ;
    for(int i=; i<n+; i++) {
        tmp = AB[x][i];
        AB[x][i] = AB[y][i];
        AB[y][i] = tmp;
    }
}
int find_max_col(int x, int n) /// 此列下方最大值
{
    double max1 = fabs(AB[x][x]);
    int res = x;
    for(int i=x+; i<n; i++) {
        if(fabs(AB[i][x]) > max1) {
            max1 = AB[i][x];
            res = i;
        }
    }
    return res;
}
void compute_gauss_X(int n) ///计算结果X
{
    if(AB[n-][n-] == )
        cerr<<"wrong： divide 0 \n";
    X[n-] = AB[n-][n]/AB[n-][n-];
    double tmp =;
    for(int i=n-; i>=; i--) {
        tmp = AB[i][n];
        for(int j=i+; j<n; j++){
            tmp -= X[j]* AB[i][j];
            //if(fabs(tmp)<10e-6) tmp = 0;
        }
        if(AB[i][i] != )
            X[i] = tmp/AB[i][i];
    }
}
void solution_gauss(int n)/// 列主元高斯消元
{
    for(int i=; i<n; i++) {
        for(int j=; j<n; j++ ) {
            AB[i][j] = A[i][j];
        }
        AB[i][n] = b[i];
    }
    int pos = ;
    double m = ;
    for(int i=; i<=n; i++) { ///标准行
        pos =find_max_col(i, n);
        if( pos != i){
            swap_cols(i, pos, n);
        }
        for(int i=; i<n; i++) {
            for(int j=; j<n+; j++) {
                cout<<AB[i][j]<<" ";
            }
            cout<<endl;
        }
        cout<<"****************************\n";
        for(int j=i+; j<n; j++) { ///标准行以下
            m = AB[j][i] / AB[i][i];
            for(int k=i; k<n+; k++) { ///此行所有数据
                AB[j][k] -= m*AB[i][k];
            }
        }
        cout<<"step# "<<i<<" :\n--------------------------\n";
        for(int i=; i<n; i++) {
            for(int j=; j<n+; j++) {
                cout<<AB[i][j]<<" ";
            }
            cout<<endl;
        }
        cout<<"----------------------------\n\n\n";
    }
    compute_gauss_X(n);
    saveT(X,n);
}

void solution_LU(int n) ///直接法LU
{
    breakdown(n);
    computeY(n);
    computeX(n);

    saveLU(n);
    saveT(Y,n);
    saveT(X,n);
}

void solution_triangle_chase(int n) ///追赶法
{
    TriangleBreakdown(n);
    TriangleY(n);
    TriangleX(n);

    saveT(Y,n);
    saveT(X,n);
}

int main()
{
    int n = ,choise=;
    cout<<"选择方法： 1.Gauss  2.direct LU  3.triangle chase : \t\t";
    cin>>choise;
    cout<<"输入矩阵大小\n";
    cin>>n;
    init(n);
    switch(choise)
    {
        case : solution_gauss(n);break;
        case : solution_LU(n); break;
        case : solution_triangle_chase(n);
    }
    return ;
}