《数值分析》实验报告-线性方程组求解

文章目录

- 1. 实验目标
- 2. 实验内容
- - 2.1 设计界面
  - 2.2 实现解法
  - - 2.2.1 高斯消元法
    - 2.2.2 克劳斯消元法
    - 2.2.3 列主元素法
  - 2.3 结果展示
- 3. 实现过程
- - 3.1 选择并设计算法
  - - 3.1.1 高斯消元法
    - 3.1.2 克劳斯消元法
    - 3.1.3 列主元素法
  - 3.2 设计 Tkinter 界面
  - 3.3 编写代码实现
  - 3.4 结果显示
- 4. 输入
- 5. 输出
- 6. 实验分析
- 7. 实验结论
- 8. 实验截图
- 9. 附录：矩阵求解部分源代码
完整代码：

1. 实验目标

本次实验的目标是使用 Python 编程语言设计并实现一个简易的线性方程组求解器。通过此实验，我们将实现三种不同的线性方程求解方法，并通过图形界面（GUI）展示各个步骤及求解结果。通过该实验，将加深对线性代数中矩阵变换和方程组求解的理解，并提升使用 Python 进行科学计算和图形界面设计的能力。

2. 实验内容

2.1 设计界面

使用 Tkinter 实现输入方程组的图形界面，包括输入增广矩阵的行数和列数的选项，动态生成矩阵的输入框，并展示求解的结果。

2.2 实现解法

2.2.1 高斯消元法

采用上三角化消元步骤并回代求解。
过程公式：
[ A[k] = A[k] - \frac{A[k][i]}{A[i][i]} A[i], \quad (k > i) ]
以及回代：
[ x_i = \frac{b_i - \sum_{j=i+1}^{n} A[i][j] \cdot x_j}{A[i][i]} ]

2.2.2 克劳斯消元法

对矩阵每一行进行归一化处理，逐行消元。
过程公式：
[ A[i][j] = \frac{A[i][j]}{A[i][i]}, \quad (j \in [0, n]) ]
并消元：
[ A[k][j] = A[k][j] - A[k][i] \cdot A[i][j], \quad (k \neq i) ]

2.2.3 列主元素法

每次选取列主元素进行消元。
过程公式：
[ \text{选择 } p = \max_{k \in [i, n]} |A[k][i]| ]
交换行：
[ A[i], A[max_row] = A[max_row], A[i] ]
然后进行消元：
[ A[k][j] = A[k][j] - \frac{A[k][i]}{A[i][i]} A[i], \quad (k > i) ]

2.3 结果展示

将三种方法的求解结果在界面中展示出来，并支持清空结果重新输入。

3. 实现过程

3.1 选择并设计算法

本实验选择了高斯消元法、克劳斯消元法和列主元素法来解线性方程组，均基于矩阵操作实现：

3.1.1 高斯消元法

先将矩阵通过行变换转化为上三角矩阵，然后从底至顶进行回代求解。

3.1.2 克劳斯消元法

直接对每行进行归一化，并将其它行中相应列清零，以确保仅有对角元素非零。

3.1.3 列主元素法

基于列主元素，即选取当前列的最大值作为主元，进行行交换以减小数值误差，提高稳定性。

3.2 设计 Tkinter 界面

使用 Tkinter 生成主窗口，包括行列数输入框、矩阵输入框、求解按钮及显示求解结果的区域。当用户点击求解按钮后，系统将获取用户输入的矩阵数据，调用相应算法进行计算，并显示结果。

3.3 编写代码实现

实现 gaosi(A)、kelaosi(A) 和 liezhu(A) 三个方法用于高斯消元法、克劳斯消元法和列主元素法的具体操作。为每个方法设置处理异常输入的功能，以确保程序在用户输入不合规矩阵时能够显示错误提示。

3.4 结果显示

使用 Label 在 result_frame 区域动态生成三种算法的求解结果，并以变量值的形式展示，如 x1=5.00, x2=-3.00 等。

4. 输入

在界面中用户需按以下步骤输入数据：

输入增广矩阵的行数和列数，行数即方程的数量，列数为未知数的数量加1（最后一列为常数项）。
点击“确定矩阵行列数”，程序将动态生成输入框用于填写每个变量的系数及常数项。
完成输入后，点击“求解矩阵”按钮，程序将自动调用三种方法求解并展示结果。

5. 输出

程序将以标签的形式分别展示三种解法的结果。例如，给定 3 个方程和 3 个变量，显示如下：

高斯消元法解：x1=5.00, x2=-3.00, x3=4.50
克劳斯消元法解：x1=5.00, x2=-3.00, x3=4.50
列主元素法解：x1=5.00, x2=-3.00, x3=4.50

6. 实验分析

正确性：三种方法在处理一般方程组时，均能获得一致的解。对于简单系数矩阵（如无小数或负数项），三者表现基本相同。
数值稳定性：列主元素法在数值稳定性上优于其它两种方法，适合在系数矩阵中包含较大范围数值或小数项时使用，以降低误差。
计算效率：对于同一个方程组，克劳斯消元法步骤较为复杂（逐行归一化），执行时间略长；高斯消元法则最快，尤其在变量数较多时表现突出。
界面设计：Tkinter 能够提供一个简易的输入框生成和信息展示的界面。矩阵规模较大时（超过 4×4），界面易变得拥挤，可考虑滚动条以改善体验。

7. 实验结论

本次实验通过实现线性方程组求解器，验证了不同方法在求解方程组中的表现。高斯消元法、克劳斯消元法和列主元素法均能够正确求解方程，但在精度、计算时间等方面有所不同。该实验不仅强化了对矩阵求解算法的理解，也通过 Tkinter 编程实践了 Python 的 GUI 开发。总体来说，这些算法可应对较小规模的线性方程组求解任务，为更大规模的计算建议使用专门的数值库。

8. 实验截图

十分简陋的前端（）

图1 - 界面初始状态，用户输入行数和列数。

图2 - 用户填写完系数矩阵后点击“求解矩阵”。

图3 - 结果显示区域，展示三种方法的求解结果。

9. 附录：矩阵求解部分源代码

# 高斯消元法
def gaosi(A):
    n = len(A)
    for i in range(n):
        for k in range(i + 1, n):
            factor = A[k][i] / A[i][i]
            for j in range(i, n + 1):
                A[k][j] -= factor * A[i][j]
    x = [0] * n
    for i in range(n - 1, -1, -1):
        x[i] = A[i][n]
        for j in range(i + 1, n):
            x[i] -= A[i][j] * x[j]
        x[i] /= A[i][i]
    return x


# 克劳斯消元法
def kelaosi(A):
    n = len(A)
    for i in range(n):
        pivot = A[i][i]
        for j in range(n + 1):
            A[i][j] /= pivot
        for k in range(n):
            if k != i:
                factor = A[k][i]
                for j in range(i, n + 1):
                    A[k][j] -= factor * A[i][j]
    return [A[i][n] for i in range(n)]


# 列主元素法
def liezhu(A):
    n = len(A)
    for i in range(n):
        max_row = max(range(i, n), key=lambda k: abs(A[k][i]))
        A[i], A[max_row] = A[max_row], A[i]
        for k in range(i + 1, n):
            factor = A[k][i] / A[i][i]
            for j in range(i, n + 1):
                A[k][j] -= factor * A[i][j]
    x = [0] * n
    for i in range(n - 1, -1, -1):
        x[i] = A[i][n]
        for j in range(i + 1, n):
            x[i] -= A[i][j] * x[j]
        x[i] /= A[i][i]
    return x

完整代码：

import numpy as np
import tkinter as tk
from tkinter import messagebox

# 高斯消元法
def gaosi(A):
    n = len(A)
    for i in range(n):
        for k in range(i + 1, n):
            factor = A[k][i] / A[i][i]
            for j in range(i, n + 1):
                A[k][j] -= factor * A[i][j]
    x = [0] * n
    for i in range(n - 1, -1, -1):
        x[i] = A[i][n]
        for j in range(i + 1, n):
            x[i] -= A[i][j] * x[j]
        x[i] /= A[i][i]
    return x


# 克劳斯消元法
def kelaosi(A):
    n = len(A)
    for i in range(n):
        pivot = A[i][i]
        for j in range(n + 1):
            A[i][j] /= pivot
        for k in range(n):
            if k != i:
                factor = A[k][i]
                for j in range(i, n + 1):
                    A[k][j] -= factor * A[i][j]
    return [A[i][n] for i in range(n)]


# 列主元素法
def liezhu(A):
    n = len(A)
    for i in range(n):
        max_row = max(range(i, n), key=lambda k: abs(A[k][i]))
        A[i], A[max_row] = A[max_row], A[i]
        for k in range(i + 1, n):
            factor = A[k][i] / A[i][i]
            for j in range(i, n + 1):
                A[k][j] -= factor * A[i][j]
    x = [0] * n
    for i in range(n - 1, -1, -1):
        x[i] = A[i][n]
        for j in range(i + 1, n):
            x[i] -= A[i][j] * x[j]
        x[i] /= A[i][i]
    return x


# 主界面类
class MatrixSolverApp:
    def __init__(self, root):
        self.root = root
        self.root.title("线性方程组求解器")

        # 初始输入行数和列数
        self.label_size = tk.Label(root, text="请输入增广矩阵的行数和列数:")
        self.label_size.pack()

        self.entry_n = tk.Entry(root, width=5)
        self.entry_n.pack()
        self.entry_m = tk.Entry(root, width=5)
        self.entry_m.pack()

        self.size_button = tk.Button(root, text="确定矩阵行列数", command=self.create_matrix_entries)
        self.size_button.pack()

        # 存放系数矩阵的框架
        self.matrix_frame = tk.Frame(root)
        self.matrix_frame.pack()

        # 存放解的框架
        self.result_frame = tk.Frame(root)
        self.result_frame.pack()

    # 生成矩阵输入框
    def create_matrix_entries(self):
        try:
            # 获取行数和列数
            self.n = int(self.entry_n.get())
            self.m = int(self.entry_m.get()) - 1  # 系数和常数项分开

            # 清空以前的输入框
            for widget in self.matrix_frame.winfo_children():
                widget.destroy()

            # 生成方程输入框
            self.entries = []
            for i in range(self.n):
                row_entries = []
                for j in range(self.m + 1):
                    # 系数项
                    if j < self.m:
                        entry = tk.Entry(self.matrix_frame, width=5)
                        entry.grid(row=i, column=2 * j)
                        row_entries.append(entry)
                        label_x = tk.Label(self.matrix_frame, text=f"x{j + 1} + " if j < self.m - 1 else f"x{j + 1} = ")
                        label_x.grid(row=i, column=2 * j + 1)
                    # 常数项
                    else:
                        entry = tk.Entry(self.matrix_frame, width=5)
                        entry.grid(row=i, column=2 * j)
                        row_entries.append(entry)
                self.entries.append(row_entries)

            # 添加确认按钮
            self.solve_button = tk.Button(self.matrix_frame, text="求解矩阵", command=self.solve)
            self.solve_button.grid(row=self.n + 1, columnspan=self.m + 2)

        except ValueError:
            messagebox.showerror("错误", "请输入有效的整数行数和列数")

    # 处理并求解
    def solve(self):
        try:
            # 读取系数矩阵
            A = []
            for i in range(self.n):
                row = [float(entry.get()) for entry in self.entries[i]]
                A.append(row)

            # 复制矩阵并进行三种求解
            self.display_results(A)

        except ValueError:
            messagebox.showerror("错误", "请确保所有系数和常数项均已填写且为数字")

    # 显示解结果
    def display_results(self, A):
        # 清空以前的结果
        for widget in self.result_frame.winfo_children():
            widget.destroy()

        # 三种解法
        A1 = [row[:] for row in A]
        A2 = [row[:] for row in A]
        A3 = [row[:] for row in A]

        result_gaosi = gaosi(A1)
        result_kelaosi = kelaosi(A2)
        result_liezhu = liezhu(A3)

        # 显示结果
        tk.Label(self.result_frame, text="高斯消元法解:").pack()
        tk.Label(self.result_frame,
                 text=", ".join([f"x{i + 1}={result_gaosi[i]:.2f}" for i in range(len(result_gaosi))])).pack()

        tk.Label(self.result_frame, text="克劳斯消元法解:").pack()
        tk.Label(self.result_frame,
                 text=", ".join([f"x{i + 1}={result_kelaosi[i]:.2f}" for i in range(len(result_kelaosi))])).pack()

        tk.Label(self.result_frame, text="列主元素法解:").pack()
        tk.Label(self.result_frame,
                 text=", ".join([f"x{i + 1}={result_liezhu[i]:.2f}" for i in range(len(result_liezhu))])).pack()


if __name__ == "__main__":
    root = tk.Tk()
    app = MatrixSolverApp(root)
    root.mainloop()