数值计算——线性方程组的迭代法

最新推荐文章于 2023-02-03 17:09:51 发布
最新推荐文章于 2023-02-03 17:09:51 发布
阅读量1.4w 收藏 73
点赞数 11
分类专栏： 数值计算 文章标签： 数值计算实验 迭代法解线性方程组 线性方程组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29721419/article/details/68486800
版权

数值计算——线性方程组的迭代法

与上一篇中的直接法相比，迭代法是从解的一个初始估计值除法，逐步对他进行改进，知道到达所需的精度，理论上来说，经过无限次的迭代之后就可以得到真解，但实际上只需要达到所需要的精度即可。下面是几种迭代法：
  • 雅克比方法
  • 高斯-赛德尔方法
  • 逐次超松弛法
使用迭代法的关键在于 ：
    1. 确定迭代变量：在可以用迭代算法解决的问题中，至少存在一个直接或间接地不断由旧值递推出新值的变量，这个变量就是迭代变量。
    2. 确定迭代关系式：所谓迭代关系式，指如何从变量的前一个值推出其下一个值的公式(或关系)。迭代关系式的建立是解决迭代问题的关键，通常可以顺推或倒推的方法来完成。
    3. 对迭代过程进行控制：在什么时候结束迭代过程?这是编写迭代程序必须考虑的问题。不能让迭代过程无休止地重复执行下去。迭代过程的控制通常可分为两种情况:一种是所需的迭代次数是个确定的值，可以计算出来;另一种是所需的迭代次数无法确定。对于前一种情况，可以构建一个固定次数的循环来实现对迭代过程的控制;对于后一种情况，需要进一步分析出用来结束迭代过程的条件。

一、雅克比方法

首先将方程组 中的系数矩阵 A 分解成三部分，即: A = L+D+U ，如图所示，


其中D为对角阵，L为下三角矩阵，U为上三角矩阵。

之后确定迭代格式:X^(k+1) = D^(-1)(b-(L+U)x^(k)) ,这里^表示的是上标，括号内数字即迭代次数(k = 0,1，......)

再选取初始迭代向量X^(0)，开始逐次迭代。

雅克比迭代法的优点明显，计算公式简单，且计算过程中原始矩阵A始终不变，比较容易并行计算。然而这种迭代方式收敛速度较慢，而且占据的存储空间较大，所以工程中一般不直接用雅克比迭代法，而用其改进方法。
使用雅克比方法并不总是收敛的，一般当矩阵式行对角占优的时候是收敛的。
程序实现： 
/**
	 * Jacobi迭代法
	 * @param a
	 * @param b
	 * @return
	 */
	public static double[] Jacobi(double[][] a, double[] b) {
		int n = a.length;
		double sum = 0;
		double e = 0.001;
		double z;
		int i;
		double[] x = new double[n];
		double[] y = new double[n];
		while (true) {
			//按迭代式迭代
			for (i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					if (i != j) {
						sum += a[i][j] * x[j];
					}
				}
				y[i] = (b[i] - sum) / a[i][i];
				sum = 0;
			}
			//达到精度后终止
			i = 0;
			while (i < n) {
				z = Math.abs(x[i] - y[i]);
				if (z > e)
					break;
				i++;
			}
			if (i != n) {
				for (i = 0; i < n; i++)
					x[i] = y[i];
			}else if (i == n)
				break;
		}
		return y;
	}

二、高斯-赛德尔方法

雅克比方法收敛速度缓慢的原因之一是它在迭代过程中并没有使用最新的信息：新的分量值只有在整个扫描过程全部完成之后才能被利用。Gauss-Seidel方法弥补了这一缺陷，一旦某个分量的新值计算出来马上将他利用。
将矩阵A分成两部分：A=(L+D)+U
选取迭代格式：x^(k+1)=(D+L)^(-1)(b-Ux^(k))
在选取初始向量，然后逐次迭代。
高斯-赛德尔方法还有一个优点就是不需要对向量x做重复存储。
程序实现： 
/**
	 * 高斯-赛德尔方法
	 * @param a
	 * @param b
	 * @return
	 */
	public static double[] GaussSeidel(double[][] a,double[] b){
		int n = a.length;
		double sum = 0;
		double e = 0.001;
		double z;
		int i;
		double[] x = new double[n];
		double[] y = new double[n];
		while (true) {
			//按迭代式迭代
			for (i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					//跟Jacobi的不同之处
					if (i < j) {
						sum += a[i][j] * y[j];
					}else if(i>j){
						sum += a[i][j] * x[j];
					}
				}
				y[i] = (b[i] - sum) / a[i][i];
				sum = 0;
			}
			//达到精度后终止
			i = 0;
			while (i < n) {
				z = Math.abs(x[i] - y[i]);
				if (z > e)
					break;
				i++;
			}
			if (i != n) {
				for (i = 0; i < n; i++)
					x[i] = y[i];
			}else if (i == n)
				break;
		}
		return y;
	}

三、逐次超松弛方法（SOR）

SOR技术可以加快Gauss-Seidel方法的收敛速度，就是从x^(k)出发，首先使用Gauss-Seidel方法计算下一步的迭代值x^(k+1)，然后取下一次迭代值为：
那么迭代式为：
当步长<1时称为低松弛即向后搜索，=1时为Gauss-Seidel，>1时为超松弛，即向前搜索
程序实现： 
/**
	 * 逐次超松弛方法SOR
	 * @param a
	 * @param b
	 * @return
	 */
	public static double[] SOR(double[][] a,double[] b,double m){
		int n = a.length;
		double sum = 0;
		double e = 0.001;
		double z;
		int i;
		double[] x = new double[n];
		double[] y = new double[n];
		while (true) {
			//按迭代式迭代
			for (i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					//跟Jacobi的不同之处
					if (i < j) {
						sum += a[i][j] * y[j];
					}else if(i>j){
						sum += a[i][j] * x[j];
					}
				}
				y[i] = (1-m)*x[i]+(m*(b[i] - sum))/ a[i][i];
				sum = 0;
			}
			//达到精度后终止
			i = 0;
			while (i < n) {
				z = Math.abs(x[i] - y[i]);
				if (z > e)
					break;
				i++;
			}
			if (i != n) {
				for (i = 0; i < n; i++)
					x[i] = y[i];
			}else if (i == n)
				break;
		}
		return y;
	}
附上完整的实验代码： 
package com.kexin.lab3;

/**
 * 用迭代法求解线性方程组： Jacobi、Gauss-Seidel、SOR
 * 
 * @author KeXin
 *
 */
public class DieDai {
	/**
	 * Jacobi迭代法
	 * @param a
	 * @param b
	 * @return
	 */
	public static double[] Jacobi(double[][] a, double[] b) {
		int n = a.length;
		double sum = 0;
		double e = 0.001;
		double z;
		int i;
		double[] x = new double[n];
		double[] y = new double[n];
		while (true) {
			//按迭代式迭代
			for (i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					if (i != j) {
						sum += a[i][j] * x[j];
					}
				}
				y[i] = (b[i] - sum) / a[i][i];
				sum = 0;
			}
			//达到精度后终止
			i = 0;
			while (i < n) {
				z = Math.abs(x[i] - y[i]);
				if (z > e)
					break;
				i++;
			}
			if (i != n) {
				for (i = 0; i < n; i++)
					x[i] = y[i];
			}else if (i == n)
				break;
		}
		return y;
	}
	/**
	 * 高斯-赛德尔方法
	 * @param a
	 * @param b
	 * @return
	 */
	public static double[] GaussSeidel(double[][] a,double[] b){
		int n = a.length;
		double sum = 0;
		double e = 0.001;
		double z;
		int i;
		double[] x = new double[n];
		double[] y = new double[n];
		while (true) {
			//按迭代式迭代
			for (i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					//跟Jacobi的不同之处
					if (i < j) {
						sum += a[i][j] * y[j];
					}else if(i>j){
						sum += a[i][j] * x[j];
					}
				}
				y[i] = (b[i] - sum) / a[i][i];
				sum = 0;
			}
			//达到精度后终止
			i = 0;
			while (i < n) {
				z = Math.abs(x[i] - y[i]);
				if (z > e)
					break;
				i++;
			}
			if (i != n) {
				for (i = 0; i < n; i++)
					x[i] = y[i];
			}else if (i == n)
				break;
		}
		return y;
	}
	/**
	 * 逐次超松弛方法SOR
	 * @param a
	 * @param b
	 * @return
	 */
	public static double[] SOR(double[][] a,double[] b,double m){
		int n = a.length;
		double sum = 0;
		double e = 0.001;
		double z;
		int i;
		double[] x = new double[n];
		double[] y = new double[n];
		while (true) {
			//按迭代式迭代
			for (i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					//跟Jacobi的不同之处
					if (i < j) {
						sum += a[i][j] * y[j];
					}else if(i>j){
						sum += a[i][j] * x[j];
					}
				}
				y[i] = (1-m)*x[i]+(m*(b[i] - sum))/ a[i][i];
				sum = 0;
			}
			//达到精度后终止
			i = 0;
			while (i < n) {
				z = Math.abs(x[i] - y[i]);
				if (z > e)
					break;
				i++;
			}
			if (i != n) {
				for (i = 0; i < n; i++)
					x[i] = y[i];
			}else if (i == n)
				break;
		}
		return y;
	}
	/**
	 * 打印数组
	 * @param result
	 */
	public static void PrintArray(String str,double[] result){
		int n = result.length;
		System.out.print(str + "\n[");
		for(int i =0;i<n;i++){
			System.out.print(result[i]+"\t");
		}
		System.out.print(']');
		System.out.println();
	}
	public static void main(String[] args) {
		//Jacobi迭代
		double[][] j1 = {{4,-1,1},{4,-8,1},{-2,1,5}};
		double[] b1 = {7,-21,15};
		double[] result1 = Jacobi(j1,b1);
		PrintArray("Jacobi迭代：",result1);
		//Gauss-Seidel迭代
		double[] result = GaussSeidel(j1,b1);
		PrintArray("Gauss-Seidel迭代：",result);
		//SOR迭代
		double m = 0.5;
		double[] result2 = SOR(j1,b1,m);
		PrintArray("m="+m+" SOR迭代：",result2);
		//交换第一个和最后一个方程
		double[][] j2 = {{-2,1,5},{4,-8,1},{4,-1,1}};
		double[] b2 = {15,-21,7};
		double[] result3 = Jacobi(j2,b2);
		PrintArray("交换方程之后Jacobi迭代：",result3);
	}

}

小黄鸭and小黑鸭
关注
  • 11
    点赞
  • 踩
  • 73
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数值计算解线性方程组迭代方法——雅克比迭代法（附源程序）.rar
11-05
雅克比迭代法求解线性方程组c++源代码，结合https://blog.csdn.net/weixin_41788456/article/details/102920383文章学习，内附有输出结果。
线性方程组的迭代解法
weixin_52508924的博客
10-27 551
线性方程迭代解法
MATLAB实现线性方程组迭代法求解 JGS 雅克比迭代 Jacobi 数值计算方法 MATLAB
12-15
结合一个题目演示了如何自编代码实现迭代法求解线性方程组，提供了雅克比迭代和JGS迭代两种方法，各函数文件独立，便于移植，题目附有解答，题目来自西工大数值计算方法作业。采用MATLAB实现。
数值计算解线性方程组迭代方法——高斯赛德尔（附源程序）.rar
11-05
高斯赛德尔，结合https://blog.csdn.net/weixin_41788456/article/details/102922848文章学习，内附有输出结果。
c++ vector 初始化_学习C++ - 向量(vector)！你今天努力了吗？
weixin_39624774的博客
11-25 451
一、向量的介绍 向量 vector 是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。 与string相同, vector 同属于STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型, 可以广义上认为是数组的增强版。 在使用它时, 需要包含头文件 vector，#include<vector> ...
数值分析-雅克比迭代法
ITGGU的博客
12-27 1万+
雅克比迭代法 雅克比迭代法就是众多迭代法中比较早且较简单的一种，其命名也是为纪念普鲁士著名数学家雅可比。雅克比迭代法的计算公式简单，每迭代一次只需计算一次矩阵和向量的乘法，且计算过程中原始矩阵A始终不变，比较容易并行计算。 迭代过程 首先将方程组中的系数矩阵A分解成三部分，即：A = L+D+U，如图1所示，其中D为对角阵，L为下三角矩阵，U为上三角矩阵。 之后确定迭代格式，X^(k+1) = B*X^(k) +f ，（这里^表示的是上标，括号内数字即迭代次数），如图1所示，其中B称为迭代矩阵，雅克比迭代法
Gauss-Seidel迭代法解方程
da_ye_zi的博客
03-22 3399
#include<stdio.h> #include<math.h> double Gauss(double x3[],double x[]) { double s=0; int i,n=3; for(i=0;i<n;i++) s=s+fabs(x3[i]-x[i]); return s; } void...
迭代算法简介
weixin_66107760的博客
02-03 3054
迭代算法简介
迭代法
SKY的专栏
08-21 1万+
一，迭代法的基本概念：迭代法事一种常用算法设计方法。迭代式一个不断用新值取代变量的旧值，或由旧值递推出变量的新值的过程。迭代机制需要以下一些要素：①迭代表达式；②迭代变量；③迭代初值；④迭代终止条件。 当一个问题的求解过程能够由一个初值使用一个迭代表达式进行反复的迭代时，便可以用效率极高的重复程序描述，所以迭代也是用循环结构实现，只不过要重复
什么是迭代（迭代法）
热门推荐
qq_61453770的博客
02-07 4万+
大家有时会将迭代和递归搞混，但是他们其实是有差别的. 递归，就是在运行的过程中调用自己。 迭代法也称辗转法，是一种不断用变量的旧值递推新值的过程，跟迭代法相对应的是直接法(或者称为一次解法)，即一次性解决问题。 迭代算法是用计算机解决问题的一种基本方法，一般用于数值计算。累加、累乘都是迭代算法的基础应用。典型案例：牛顿迭代法”。 在可以用迭代算法解决的问题中，至少存在一个直接或间接地不断由旧值递推出新值的变量，这个变量就是迭代变量。 在什么时候结束迭代过程？ 这是编写迭代程序必须考虑的问题。不能让迭代.
线性方程组迭代解法——追赶法
12-25
改程序基于线性方程组迭代解法——追赶法编写，主要解决工程中所需求解的大规模线性方程组问题。
解线性方程组-(Jacobi)雅克比迭代法 - 北太天元
最新发布
04-23
解线性方程组——(Jacobi)雅克比迭代法 | 北太天元
Python 科学计算
09-20
2.5.2 解线性方程组.............................67 2.6 掩码数组 ....................................... 69 2.7 文件存取 ....................................... 72 2.8 内存映射数组 ........................
数值计算——多项式插值
小黄鸭的博客
05-03 1万+
数值计算——多项式插值 插值：用某个函数去拟合给定的数据，该函数在给定的数据点的函数值与数据值相等。在离散数据的基础上补插连续函            数，使得这条连续曲线通过全部给定的离散数据点。插值是离散函数逼近的重要方法，利用它可通过函数在有限            个点处的取值状况，估算出函数在其他点处的近似值。可以用来估计未知位置上的数据点。 多项式插值：这是最常见的一种函数插值
数值计算——线性最小二乘问题
小黄鸭的博客
04-08 7760
数值计算——线性最小二乘问题         最小二乘法（又称最小平方法）是一种数学优化技术。它通过最小化误差的平方和寻找数据的最佳函数匹配。利用最小二乘法可以简便地求得未知的数据，并使得这些求得的数据与实际数据之间误差的平方和为最小。         m×n的线性方程组Ax=b是否有解？就是b能否表示成A的列向量的线性组合，当m=n时，肯定有解；当m>n，若b∈span(A)那么有解，否
数值计算——最小二乘拟合二元一次多项式
小黄鸭的博客
04-15 7108
数值计算——最小二乘拟合二元一次多项式 最小二乘拟合： 推导过程：      1. 设拟合多项式为：                 2. 各点到这条曲线的距离之和，即偏差平方和如下：                 3. 为了求得符合条件的a值，对等式右边求ai偏导数，因而我们得到了：
数值计算——求解非线性方程组
小黄鸭的博客
04-30 5409
数值计算——求解非线性方程组         上一篇是求解的非线性方程，但是并不能简单的扩展到n维的情况下。下面是使用牛顿法和割线法求解非线性方程组： 1、牛顿法       需要求方程组的雅克比矩阵，即对每个变量求偏导：       算法：        代码： package com.kexin.lab7; import com.kexin.lab3.*; /**
数值计算——线性方程组的解法
小黄鸭的博客
03-25 4218
数值计算——线性方程组的解法 矩阵分解 矩阵分解是将矩阵拆解为数个矩阵的乘积，可分为三角分解、满秩分解、QR分解、Jordan分解和SVD(奇异值)分解等，常见的有三种: 1)三角分解法 (LU)：将原正方矩阵分解成一个上三角形矩阵或是排列的上三角形矩阵和一个 下三角形矩阵，用途主要在简化一个大矩阵的行列式值的计算过程，求 反矩阵，和求解联立方程组。 2)QR 分解法 (QR) 3
matlab线性方程组迭代法
09-21
matlab中的线性方程组迭代法主要包括Gauss-Seidel迭代和Jacobi迭代。这两种方法都是通过按照一定规则对未知数进行更新和逼近的方式来求解线性方程组。 Gauss-Seidel迭代方法是一种逐次逼近法，它在每一次迭代中使用上一次迭代中已经更新过的未知数来计算当前未知数的逼近值。具体步骤如下： 1. 初始化未知数的逼近值。 2. 根据线性方程组中的每个方程，使用已知的逼近值来计算当前未知数的逼近值。 3. 重复步骤2，直到未知数的逼近值收敛到所需精度。 Jacobi迭代方法是一种同步逼近法，它在每一次迭代中使用上一次迭代中所有未知数的逼近值来计算当前所有未知数的逼近值。具体步骤如下： 1. 初始化未知数的逼近值。 2. 根据线性方程组中的每个方程，使用已知的逼近值来计算当前未知数的逼近值。 3. 更新所有未知数的逼近值。 4. 重复步骤2和3，直到未知数的逼近值收敛到所需精度。 以上是matlab中线性方程组迭代法的基本原理和步骤。如果您有其他相关问题，请提出。 相关问题： 1. 迭代法在求解线性方程组中有哪些优缺点？ 2. 如何选择合适的迭代法和收敛准则？ 3. 迭代法在求解大规模线性方程组时有什么特点和应用？

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小黄鸭and小黑鸭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值