列主元消去法&全主元消去法——Java实现

最新推荐文章于 2024-04-20 11:02:39 发布
最新推荐文章于 2024-04-20 11:02:39 发布
阅读量3k 收藏 9
点赞数 1
分类专栏： # Java Algorithm 文章标签： Java 高斯消元法 继承 列主元 全主元
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pfdvnah/article/details/84674620
版权
Java 同时被 2 个专栏收录
174 篇文章 1 订阅
订阅专栏
Algorithm
36 篇文章 0 订阅
订阅专栏

1、列主元消去法

pivot.column.ColumnPivot 类：通过构造方法传入增广矩阵，用 getRoot() 方法获取方程组的根。

test.Test 类：用于输入数据。测试 pivot.column.ColumnPivot 的功能。（文末有测试数据）

本文使用的列选主元消去法的计算过程参考 列主元消去法『百度百科』。

代码如下：

package pivot.column;

import java.util.Arrays;

// 列主元消去法
public class ColumnPivot {

	private double[][] matrix;// 增广矩阵
	private int n;// 系数矩阵的阶数

	// 参数为增广矩阵
	public ColumnPivot(int[][] matrix) {
		n = matrix.length;// 系数矩阵的阶
		this.matrix = new double[n][n + 1];
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j <= n; ++j) {
				this.matrix[i][j] = matrix[i][j];// 数据类型转换
			}
		}
	}

	// 参数为增广矩阵
	public ColumnPivot(double[][] matrix) {
		n = matrix.length;// 系数矩阵的阶
		this.matrix = new double[n][n + 1];
		for (int i = 0; i < n; ++i) {// 备份
			this.matrix[i] = Arrays.copyOf(matrix[i], n + 1);
		}
	}

	// 获取方程组的根
	public double[] getRoot() {
		for (int k = 0; k < n - 1; ++k) {
			int i = columnPivoting(k);// 列选主元
			if (matrix[i][k] == 0) {
				return new double[0];// 无解
			}
			if (i != k) {
				lineSwitch(k, i);// 行交换
			}
			elimination(k);// 消元
		}
		return backSubstitution();// 回代求根并返回根
	}

	// 选第k列的主元
	private int columnPivoting(int k) {
		double maxVal = Math.abs(matrix[k][k]);
		int maxRow = k;
		for (int i = k + 1; i < n; ++i) {// 查找值最大的行下标
			double val = Math.abs(matrix[i][k]);
			if (val > maxVal) {
				maxVal = val;
				maxRow = i;
			}
		}
		return maxRow;// 返回行下标
	}

	// a[l1][j]和a[l2][j]交换，j=l1,l1+1,...,n
	private void lineSwitch(int l1, int l2) {// l1 < l2
		for (int j = l1; j <= n; ++j) {
			double temp = matrix[l1][j];
			matrix[l1][j] = matrix[l2][j];
			matrix[l2][j] = temp;
		}
	}

	// 消元
	private void elimination(int k) {
		for (int i = k + 1; i < n; ++i) {
			matrix[i][k] /= matrix[k][k];// 倍数
			for (int j = k + 1; j <= n; ++j) {
				matrix[i][j] -= matrix[i][k] * matrix[k][j];
			}
		}
	}

	// 回代求根
	private double[] backSubstitution() {
		double[] root = new double[n];
		for (int i = n - 1; i >= 0; --i) {
			for (int j = i + 1; j < n; ++j) {
				matrix[i][n] -= matrix[i][j] * root[j];
			}
			root[i] = matrix[i][n] / matrix[i][i];
		}
		return root;
	}

}
package test;

import java.util.Scanner;
import pivot.column.ColumnPivot;

// 测试类
public class Test {

	public static void main(String[] args) {
		// 输入增广矩阵
		Scanner sc = new Scanner(System.in);
		int order = sc.nextInt();
		int[][] matrix = new int[order][order + 1];
		for (int i = 0; i < order; ++i) {
			for (int j = 0; j <= order; ++j) {
				matrix[i][j] = sc.nextInt();
			}
		}
		sc.close();
		
		ColumnPivot cp = new ColumnPivot(matrix);// 创建对象
		double[] root = cp.getRoot();// 获取方程组的根
		
		// 输出结果
		if (root.length == 0) {
			System.err.println("方程组无解！");
		} else {
			for (int i = 0; i < root.length; ++i) {
				System.out.print("X" + (i + 1) + " =");
				System.out.printf("%6.2f\n", root[i]);
			}
		}
	}

}

2、全主元消去法

pivot.complete.CompletePivot 类用于全主元计算方程组的根。用 getRoot() 方法获取根。

test.Test 类用于输入数据测试 pivot.complete.CompletePivot 类的功能。（文末有测试数据）

相对于列选主元，全主元需要进行必要的列交换，以及记录根的位置。其他基本相似。

代码如下：

package pivot.complete;

import java.util.Arrays;

// 全主元消去法
public class CompletePivot {

	private double[][] matrix;// 增广矩阵
	private int n;// 系数矩阵的阶数
	private int[] rootOrder;// 保存根的顺序，因为列交换会改变根的顺序

	// 参数为增广矩阵
	public CompletePivot(int[][] matrix) {
		n = matrix.length;// 系数矩阵的阶
		this.matrix = new double[n][n + 1];
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j <= n; ++j) {
				this.matrix[i][j] = matrix[i][j];// 数据类型转换
			}
		}
	}

	// 参数为增广矩阵
	public CompletePivot(double[][] matrix) {
		n = matrix.length;// 系数矩阵的阶
		this.matrix = new double[n][n + 1];
		for (int i = 0; i < n; ++i) {// 备份
			this.matrix[i] = Arrays.copyOf(matrix[i], n + 1);
		}
	}

	// 获取方程组的根
	public double[] getRoot() {
		rootOrder = new int[n];
		for (int i = 0; i < n; ++i) {
			rootOrder[i] = i;// 初始化根的顺序
		}
		
		for (int k = 0; k < n - 1; ++k) {
			int[] coords = completePivoting(k);// 全选主元获取主元坐标
			if (matrix[coords[0]][coords[1]] == 0) {
				return new double[0];// 无解
			}
			if (coords[0] != k) {
				lineSwitch(k, coords[0]);// 行交换
			}
			if (coords[1] != k) {
				columnSwitch(k, coords[1]);// 列交换
			}
			elimination(k);// 消元
		}
		return backSubstitution();// 回代求根并返回根
	}

	// 全选主元
	private int[] completePivoting(int k) {
		double maxVal = Math.abs(matrix[k][k]);
		int[] coords = { k, k };// 主元坐标
		for (int i = k; i < n; ++i) {
			for (int j = k; j < n; ++j) {
				double val = Math.abs(matrix[i][j]);
				if (val > maxVal) {
					maxVal = val;
					coords[0] = i;
					coords[1] = j;
				}
			}
		}
		return coords;
	}

	// a[l1][j]和a[l2][j]交换，j=l1,l1+1,...,n
	private void lineSwitch(int l1, int l2) {// l1 < l2
		for (int j = l1; j <= n; ++j) {
			double temp = matrix[l1][j];
			matrix[l1][j] = matrix[l2][j];
			matrix[l2][j] = temp;
		}
	}

	// a[i][c1]和a[i][c2]交换，i=c1,c1+1,...,n-1
	private void columnSwitch(int c1, int c2) {// c1 < c2
		for (int i = 0; i < n; ++i) {// 整列都要交换！！！
			double temp = matrix[i][c1];
			matrix[i][c1] = matrix[i][c2];
			matrix[i][c2] = temp;
		}
		// 交换根的顺序
		int temp = rootOrder[c1];
		rootOrder[c1] = rootOrder[c2];
		rootOrder[c2] = temp;
	}

	// 消元
	private void elimination(int k) {
		for (int i = k + 1; i < n; ++i) {
			matrix[i][k] /= matrix[k][k];// 倍数
			for (int j = k + 1; j <= n; ++j) {
				matrix[i][j] -= matrix[i][k] * matrix[k][j];
			}
		}
	}

	// 回代求根，注意rootOrder的使用，多体会
	private double[] backSubstitution() {
		double[] root = new double[n];
		for (int i = n - 1; i >= 0; --i) {
			for (int j = n - 1; j > i; --j) {
				matrix[i][n] -= matrix[i][j] * root[rootOrder[j]];
			}
			root[rootOrder[i]] = matrix[i][n] / matrix[i][i];
		}
		return root;
	}

}
package test;

import java.util.Scanner;
import pivot.complete.CompletePivot;

// 测试类
public class Test {

	public static void main(String[] args) {
		// 输入增广矩阵
		Scanner sc = new Scanner(System.in);
		int order = sc.nextInt();
		int[][] matrix = new int[order][order + 1];
		for (int i = 0; i < order; ++i) {
			for (int j = 0; j <= order; ++j) {
				matrix[i][j] = sc.nextInt();
			}
		}
		sc.close();

		CompletePivot cp = new CompletePivot(matrix);
		double[] root = cp.getRoot();
		
		// 输出结果
		if (root.length == 0) {
			System.err.println("方程组无解！");
		} else {
			for (int i = 0; i < root.length; ++i) {
				System.out.print("X" + (i + 1) + " =");
				System.out.printf("%6.2f\n", root[i]);
			}
		}
	}

}

3、测试数据

测试数据1：

4
  2  10   0  -3  10
 -3  -4 -12  13   5
  1   2   3  -4  -2
  4  14   9 -13   7

X1 =  1.00
X2 =  2.00
X3 =  3.00
X4 =  4.00

测试数据2：

3
 1  2  3 10
 4  3  1 19
 2  5  2 18

X1 =  3.00
X2 =  2.00
X3 =  1.00

 

wowpH
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
列主元消去法例题详解_列主元消去法&全主元消去法——Java实现
weixin_39917291的博客
12-22 1382
Gauss.javapackage Gauss;/*** @description TODO 父类,包含高斯列主元消去法和全主元消去法的共有属性和方法* @author PengHao* @date 2018年12月1日 上午9:44:40*/public class Gauss {protected double[][] augmentedMatrix; // 增广矩阵protected int...
高斯消去法的简单实现——Matlab
03-18
总结来说，高斯消去法是解决线性方程组的重要工具，其变体如列主元、全主元和平衡加权方法分别针对数值稳定性、唯一性和条件数进行了优化。在Matlab中，我们可以利用内置函数或自定义代码灵活实现这些方法，以适应...
三种消元法（全主元、Gauss消去法、列主元）
04-23
三种消元法（全主元、Gauss消去法、列主元）三种消元法（全主元、Gauss消去法、列主元）三种消元法（全主元、Gauss消去法、列主元）三种消元法（全主元、Gauss消去法、列主元）
解线性方程组——直接解法：(Gauss)高斯消去法、列主元、全主元 | 北太天元 or matlab
最新发布
以算法实现为主
04-20 1547
线性方程组的直接解法:(Gauss)高斯消去法、列主元、全主元 。 主要以代码实现为主，使用软件：北太天元
Gauss消元法求解线性方程组的Matlab实现（列主元、全主元）
热门推荐
m0_58999071的博客
03-19 1万+
最近数值分析有作业要求用Matlab实现Gauss消元法，记录在此。
数值分析_Gauss的全消元与列消元
qq_17424119的博客
11-11 849
test
矩阵变换---高斯全主元消去法---解线性非齐次方程组
floracuu的博客
02-13 5257
1. 下图是初始时的增广矩阵，解方程组的关键就是将矩阵变换成三角矩阵，于是此方程组的解为 [ 1, 2, 3, 4 ] 2.主元：第 i 行的主元是a [ i ] [ i ] 一行一行的处理，画圈的是处理每一行时的主元 可以看到，每轮的主元都不为0，这种情况较为简单，先讨论这种情况 把第0行的主元素变成1（对该行的所有元素分别除以主元素） 用主元素......
列主高斯消元法
weixin_61057398的博客
09-25 1万+
在高斯消元法过程中，回代的过程是将主对角线上的主元作为除数(这个也是将主元作为除数的)，但是一旦遇到主元上的数非常的小，即小主元。由误差分析的知识得，如果将小的数字作为除数，那就会带来误差，因此为了避免误差应当避免小主元做除数。所以我们引入了列主高斯消去法。
这四个程序分别为高斯消去法、列主元消去法、全主元消去法解线性方程组和Gauss-Jordan消元法求矩阵的逆。程序MATLAB
07-12
在本文中，我们将深入探讨四种不同的数学方法，用于解决线性方程组和求解矩阵的逆：高斯消去法、列主元消去法、全主元消去法以及Gauss-Jordan消元法。这些算法是线性代数中的基本工具，广泛应用于工程、物理、计算机...
使用matlab高斯消去法、列主元高斯消去法计算n阶线性方程组
11-15
在MATLAB代码中，列主元高斯消去法的实现包括： 1. 同样设定n和矩阵A、b，然后在每一步消去之前，找到当前列的最大绝对值元素所在的位置u。 2. 交换最大元所在行与当前行，确保A(k,k)是当前列的最大元素。 3. 执行...
列主元高斯消去法进行解方程
03-28
列主元高斯消去法是一种数值线性代数中的算法...总结来说，列主元高斯消去法是解决线性方程组的重要工具，通过C语言实现可以提供高效的计算能力。在编程时，要注意数值稳定性和错误处理，以确保程序的正确性和可靠性。
列主元消去法解方程组
03-21
列主元消去法解方程组比起全主元，计算过程要简单很多，里面包括matlab代码及其注释说明，还有一个解方程组的例子，希望对大家有帮助。
数值计算（一）之解线性方程组（高斯消去法，列选主元消去法，全选主元消去法，杜立特尔分解，克洛特分解，乔里斯基分解）
Yuki_fx的博客
01-26 6292
解线性方程组即解一个多元一次方程组，例如 目录 消去法 分解法   消去法 原理 没有学过高级的解法也没关系，凭借我们初高中的知识足以解决这个问题 这是一个多元一次方程组，拥有n个未知量，也有n方程 我们可以通过对一个方程组进行同等变形后与其他方程组相加减，消去其他未知量 最后变为一个仅含有一个未知量的方程，求解后逐次回带，接触其他未知数 当我们接触...
【Python算法】数值分析—列主元高斯消元法——附源码
qq_50920297的博客
04-16 1万+
Python算法实现列主元高斯消元法——附源码
计算方法——C语言实现——全主元高斯消元法求解非线性方程
you_big_father的博客
10-11 3014
最近在上计算方法这门课，要求是用MATLAB做练习题，但是我觉得C语言也很棒棒啊~ 题目： 高斯消元法是线性方程组的直接解法，可能会造成很大的失真，尤其是高斯顺序消元法，对方法进行改进，使每次都选取绝对值最大的元素为主元，使其为乘数的分母，控制舍入误差的扩大，失真较小。代码都是上上个星期写的，暂时就不注释了…… 使用VS2017，代码如下： //使用全主元高斯消元法求解线性方程组 #includ...
线性代数 --- Gauss消元的部分主元法和完全主元法
松下J27录放机
05-18 7283
Gauss消元的部分主元法和完全主元法
全选主元Gauss 消元法
七哥的专栏
03-20 7536
全选主元Gauss消元法，全选主元高斯消元法。这个算法是健壮的（数学术语）。我们通过选主元的方法来弥补顺序Gauss消元法的弊端，增加了pivrow和pivcol来记录包含主元素的行和列。由线性代数行列变换的知识知道，增广益矩阵行变换时，方程的解不变，但是列变换时，未知数的顺序发生了交换，因此需要记录列交换的信息在pivcol中，以便求解后还原。
选主元的高斯-约当（Gauss-Jordan）消元法解线性方程组和求逆矩阵
bookish_2010_prj的专栏
03-25 4741
<br />选主元的高斯-约当（Gauss-Jordan）消元法在很多地方都会用到，例如求一个矩阵的逆矩阵、解线性方程组（插一句：LM算法求解的一个步骤），等等。它的速度不是最快的，但是它非常稳定（来自网上的定义：一个计算方法，如果在使用此方法的计算过程中，舍入误差得到控制，对计算结果影响较小，称此方法为数值稳定的），同时它的求解过程也比较清晰明了，因而人们使用较多。下面我就用一个例子来告诉你Gauss-Jordan法的求解过程吧。顺便再提及一些注意事项以及扩展话题。<br />对本文中所提到的“主元”等概
高斯消元法（Gauss Elimination）
qq_52317884的博客
02-04 3557
是线性代数中的一个算法。 可用来求解线性方程组，可以求出矩阵的秩和可逆方阵的逆矩阵。 通过逐步消除未知数来将原始线性系统转化为另一个更简单的等价系统。 原理：用初等行变换将增广矩阵转换为行阶梯矩阵，然后回代求出方程解。 顺序消去法： 将 Ax = b 按照从上至下、从左至右的顺序化为上三角方程组，中间过程不对矩阵进行交换。 过程： 局限： 每次运算时，必须保证对角线上的元素不为0（即运算中的分母不为0），否则算法无法继续进行。 即使不为0，但如果绝对值很小，由于第k次运算中在分母位置，因此除数会引起很大
matlab实现列主元消去法
01-17
下面是Matlab实现列主元素消去法的代码： ```matlab function [x] = column_pivot_elimination(A, b) n = size(A, 1); x = zeros(n, 1); for k = 1:n-1 % 寻找第k列从第k行开始的最大元素 [~, max_index] = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值