高斯消元法Java、C、Fortran实现代码

最新推荐文章于 2022-11-14 16:36:52 发布
最新推荐文章于 2022-11-14 16:36:52 发布
阅读量930 收藏 12
点赞数 1
分类专栏： sdsc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36706625/article/details/99958148
版权

Java实现：

package zz;

public class Gauss {

	// 高斯消元法
	public float[] guass(float[][] arr) {

		float[] result = solution(arr);
		for (int i = 0; i < arr.length; i++) {
			result[i] = arr[i][arr[0].length - 1];
		}
		
		System.out.println("高斯消元之后：");
		printArr(arr);

		for (float f : result) {
			System.out.print(f + " ");
		}
		return result;
	}

	/*
	 * 结果在行列式中 所以 列式比行数多1
	 */
	public float[] solution(float[][] arr) {
		int row = arr.length; // 行数
		int col = arr[0].length; // 列数
//		System.out.println("row = " + row + " col = " + col); 
		float[] result = new float[row]; // 有多少个方程就有多少个未知数， 所以结果的个数为 行数

		for (int i = 0; i < row; i++) {
			int maxRow = SelectIndex(arr, i);

			// 寻找最大行、交换
			if (maxRow != i) {
				swapRow(arr, i, maxRow);
			}

			// 归一化 当前行 每一个元素都除以当前 arr[i][i] 上的元素，归一化
			float divNum = arr[i][i];
			for (int k = i; k < col; k++) { // 当前行 的每一列元素都除以这个数
				arr[i][k] /= divNum;
			}

			// 用这个1， 消去下面所有行的数
			arr = elimination(arr, i);

		}

//		System.out.println("回代啦");
		// 回代 从最后一行开始
		backProgram(arr);

		return result;
	}

	/*
	 * 从最后一行回代，得到结果
	 */
	public float[][] backProgram(float[][] arr) {

		int row = arr.length; // 行
		int col = arr[0].length; // 列
		for (int i = row - 1; i >= 0; i--) {
			for (int j = i - 1; j >= 0; j--) {
//				System.out.println("arr[" + j + "][" + (col - 1) + "] = " + arr[j][col - 1]);
//				System.out.println("arr[" + j + "][" + i + "] = " + arr[j][i]);
//				System.out.println("arr[" + i + "][" + i + "] = " + arr[i][i]);
//				System.out.println("arr[" + j + "][" + i + "] * arr[" + i + "][" + (col - 1) + "] = "
//						+ arr[j][i] * arr[i][col - 1]);
//				printArr(arr);
				arr[j][col - 1] -= arr[j][i] * arr[i][col - 1];
				arr[j][i] = 0;

//				printArr(arr);
			}

		}

		return arr;
	}

	/*
	 * 用当前行消去下面的所有元素
	 */
	public float[][] elimination(float[][] arr, int i) {
		int row = arr.length;
		int col = arr[0].length;
		float subNum;
		for (int k = i + 1; k < row; k++) { // i行消去下面的行
			subNum = arr[k][i];
			for (int j = i; j < col; j++) {
				arr[k][j] -= (arr[i][j] * subNum);
			}
		}

		return arr;
	}

	/*
	 * arr 为行列式 i行，j列 寻找 i -> row 这些行中 j列上最大的元素 并返回该行的下标
	 */
	public int SelectIndex(float[][] arr, int j) {
		int row = arr.length;
		int index = j;

		// 寻找 j列中最大的元素的下标
		for (int k = j; k < row; k++) {
			if (Math.abs(arr[k][j]) > Math.abs(arr[index][j])) {
				index = k;
			}
		}

		return index;
	}

	/*
	 * 交换 i, j 两行上的所有元素
	 */
	public float[][] swapRow(float[][] arr, int i, int j) {
		int col = arr[0].length; // 行列式的列数
		float tmp;

		for (int k = 0; k < col; k++) {
			tmp = arr[i][k];
			arr[i][k] = arr[j][k];
			arr[j][k] = tmp;
		}

		return arr;
	}

	public void printArr(float arr[][]) {
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[0].length; j++) {
				System.out.print(arr[i][j] + "   ");
			}
			System.out.println();
		}
		System.out.println();
	}

	public static void main(String[] args) {
		float arr[][] = { { 2, 3, 11, 5, 2 }, { 1, 1, 5, 2, 1 }, { 2, 1, 3, 2, -3 }, { 1, 1, 3, 3, -3 } };
		
		
		Gauss gauss = new Gauss();
		System.out.println("高斯消元求解前：");
		gauss.printArr(arr);
		gauss.guass(arr);
		
	}

}

运行结果：

 

C语言实现：

#include "stdio.h"
#include "math.h"

float *gauss(float *arr, int row, int col);
float *solution(float *arr, int row, int col);
float *backProgram(float *arr, int row, int col);
float *elimination(float *arr, int row, int col, int i);
int SelectIndex(float *arr, int row, int col, int i);
float *swapRow(float *arr, int row, int col, int i, int j);

void printArr(float *arr)
{
    for(int i = 0; i < 4; i++)
    {
        for(int j = 0; j < 5; j++)
        {
            printf("%f ", arr[i * 5 + j]);
        }
        printf("\n");
    }

}


// 高斯消元函数
float *gauss(float *arr, int row, int col)
{
    float *result = solution(arr, row, col);
    
    return result;
}

// row 为行数， col为列数，
float *solution(float *arr, int row, int col)
{
    for(int i = 0; i < row; i++)
    {
//        printf("变化前来一下\n");
//          printArr(arr);        

        int maxRow = SelectIndex(arr, row, col, i);

        if(maxRow != i)
        {
            swapRow(arr, row, col, i, maxRow);
        }

        float divNum = arr[i * col + i];
        for(int k = i; k < col; k++)
        {
            arr[i * col + k] /= divNum;
        }
        
//        printf("变化后来一下\n");
//        printArr(arr);

        arr = elimination(arr, row, col, i);
    }

    backProgram(arr, row, col);

    return arr;
}


// 回代、求值
float *backProgram(float *arr, int row, int col)
{
    for(int i = row - 1; i>= 0; i--)
    {
        for(int j = i - 1; j >= 0; j--)
        {
            arr[j * col + col - 1] -= arr[j * col + i] * arr[i * col + col - 1];
            arr[j * col + i] = 0;
        }
    }

    return arr;
}


//消去当前行下面的所有元素
float *elimination(float *arr, int row, int col, int i)
{
    float subNum;
    for(int k = i + 1; k < row; k++) // 当前行到下面的所有行的循环
    {
        subNum = arr[k * col + i];
        for(int kk = i; kk < col; kk++) // 这一行中 列的处理
        {
            arr[k * col + kk] -= (arr[i * col + kk] * subNum);
        }
    }
    
    return arr;
}


// 求最大行
int SelectIndex(float *arr, int row, int col, int i)
{
    int index = 0;
    float max = 0;
    for(int k = i * col + i; k < row * col; k += col)
    {
        if(fabs(max) < fabs(arr[k]))
        {
            max = arr[k];
            index = k;
        }

    } 
    return index / col;
}

// 两行交换
float *swapRow(float *arr, int row, int col, int i, int j)
{
    float tmp;
    for(int k = 0; k < col; k++)
    {
        tmp = arr[i * col + k];
        arr[i * col + k] = arr[j * col + k];
        arr[j * col + k] = tmp;        
    }

    return arr;
}




// 主函数
int main()
{
    float arr[] = {2, 3, 11, 5, 2,
                    1, 1, 5, 2, 1,
                    2, 1, 3, 2, -3,
                    1, 1, 3, 3, -3};

    printf("高斯消元之前：\n");
    printArr(arr);

    float *a = gauss(arr, 4, 5);

    printf("\n高斯消元求解后：\n");    
    printArr(arr);

    return 0;
}

 

运行结果如图：

 

Fortran实现：

SUBROUTINE printArr(arr, row, col) ! 数组打印输出函数
IMPLICIT NONE
INTEGER, INTENT(IN) :: row, col ! 行列式的行列
REAL, DIMENSION(row * col), INTENT(INOUT) :: arr

INTEGER :: i, j

forCol: DO i = 1, row
    forRow: DO j = 1, col
        WRITE(*, 100, advance='no') arr(i * col + j - col)
        100 FORMAT (1F10.4)
    END DO forRow

    WRITE(*,*)
END DO forCol

END SUBROUTINE printArr


! 高斯消元主程序
SUBROUTINE solution(arr, row, col)
IMPLICIT NONE

INTEGER, INTENT(IN) :: row, col
REAL, DIMENSION(row * col), INTENT(INOUT) :: arr

INTEGER :: i, j, maxRow, k
REAL :: divNum

forROW: DO i = 1, row
    ! 寻找最大元
    maxRow = i
    
!    WRITE(*,*) '打印出来，找bug'
!    CALL PrintArr(arr, 4, 5)

    CALL selectIndex(arr, row, col, maxRow)
    
    IF (maxRow /= i) THEN
        CALL swapRow(arr, row, col, i, maxRow)
    END IF

!    WRITE(*,*) '行交换之后是咋样子的呢'
!    CALL PrintArr(arr, 4, 5)
!    WRITE(*,*)

    divNum = arr(i * col - col + i)
    
    DO k = i, col
        arr(i * col - col + k) = arr(i * col - col + k) / divNum
    END DO

    CALL elimination(arr, row, col, i)
END DO forRow

CALL backProgram(arr, row, col)

END SUBROUTINE solution


! 回代、求解
SUBROUTINE backProgram(arr, row, col)
IMPLICIT NONE

INTEGER, INTENT(IN) :: row, col
REAL, DIMENSION(row * col), INTENT(INOUT) :: arr

INTEGER :: i, j

forRow : DO i = row, 1, -1
    forCol : DO j = i - 1, 1, -1
!        WRITE(*,*) 'i =', i, ' j =', j
        arr(j * col) = arr(j * col) - arr(j * col - col + i) * arr(i * col)
        arr(j * col - col + i) = 0
    END DO forCol
!    WRITE(*,*)
END DO forRow 

END SUBROUTINE backProgram



!消去当前行下面的元素
SUBROUTINE elimination(arr, row, col, k)
IMPLICIT NONE

INTEGER, INTENT(IN) :: row, col, k
REAL, DIMENSION(row * col), INTENT(INOUT) :: arr

INTEGER :: i, j
REAL :: subNum ! 临时变量，用于消去其他的数

!WRITE(*,*)'消去元素前'
!CALL PrintArr(arr, 4, 5)

forRow : DO i = k + 1, row
    subNum = arr(i * col - col + k)
    forCol : DO j = k, col
        arr(i * col - col + j) = arr(i * col - col + j) - (arr(k * col - col + j) * subNum)   
    END DO forCol
END DO forRow

!WRITE(*,*) '消除完毕！'
!CALL PrintArr(arr, 4, 5)
!WRITE(*,*)

END SUBROUTINE elimination


!  寻找最大元的方法
SUBROUTINE selectIndex(arr, row, col, k)
IMPLICIT NONE

INTEGER, INTENT(IN) :: row, col
INTEGER, INTENT(INOUT) :: k
REAL, DIMENSION(row * col), INTENT(INOUT) :: arr


INTEGER :: index, i
REAL :: max = 0
index = k ! 初始化一下， 找不到自己就是最大的
max = 0 ! 不初始化一下， 值一直是上一次的值 zz
!WRITE(*,*)'初始化一下 max =', max

forMax: DO i = k, row
!    WRITE(*,*) 'max =', max, 'ABS(arr(i)) =', ABS(arr(i * col - col + k)), 'max < arr ?',&
!        (ABS(max) < ABS(arr(i * col - col + k))) 
    IF (ABS(max) < ABS(arr(i * col - col + k))) THEN
        max = arr(i * col - col + k)
!        WRITE(*,*)'进来了比他小进来了 i = ', i, 'max =', max, ' arr = ', arr(i * col -col +k)
        index = i
!        WRITE(*,*) '这个是大于还是小于嘛 max =', max 
    END IF
END DO forMax

k = index ! 传递回去

END SUBROUTINE selectIndex


! 交换两行的函数
SUBROUTINE swapRow(arr, row, col, i, j)
IMPLICIT NONE

INTEGER, INTENT(IN) :: row, col, i, j
REAL, DIMENSION(row * col), INTENT(INOUT) :: arr

REAL :: tmp ! 临时变量，用于交换两个数
INTEGER :: k

!WRITE(*,*) '真的需要交换吗？ i =', i, ' j =', j
DO k = 1, col
!    WRITE(*,*) '在行交换里面输出'
!    CALL PrintArr(arr, 4, 5)
!    WRITE(*,*)
    tmp = arr(i * col - col + k)
    arr(i * col - col + k) = arr(j * col - col + k)
    arr(j * col - col + k) = tmp
END DO

END SUBROUTINE swapRow







PROGRAM gaussian  ! 高斯消元主体函数
IMPLICIT NONE

REAL, DIMENSION(20):: arr
arr = [2, 3, 11, 5, 2, &
        1, 1, 5, 2, 1, &
        2, 1, 3, 2, -3,&
        1, 1, 3, 3, -3]
WRITE(*,*) '高斯消元前：'
CALL printArr(arr, 4, 5)    

CALL solution(arr, 4, 5)

WRITE(*,*) '高斯消元后：'
CALL printArr(arr, 4, 5)

END PROGRAM gaussian

 

运行结果图：

 

 

 

 

浮沉_y
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高斯消去法解方程组fortran编辑
04-22
高斯消元法求解线性方程组，用fortran语言编辑
列主元的高斯消元法（FORTRAN）
ABS=1/0
09-26 2574
列主元的高斯消元法（FORTRAN） 代码如下 下面展示一些 内联代码片。 program Guass1 real,dimension(:,:),allocatable::arr real,dimension(:),allocatable::x real a integer i,j,k,n !输入、输出数列 write(*,*)'请输入需要计算的系数矩阵的大小n=' read*,n allocate(arr(n,n+1)) allocate(x(n)) write(*,*)'请以列为主次序依次输入矩阵元素(
高斯消元法（Fortran）
ABS=1/0
09-26 2865
高斯消元法（FORTRAN) 代码如下 program Guass1 real,dimension(:,:),allocatable::arr real,dimension(:),allocatable::x real a integer i,j,k,n !输入、输出数列 write(*,*)'请输入需要计算的系数矩阵的大小n=' read*,n allocate(arr(n,n+1)) allocate(x(n)) write(*,*)'请以列为主次序依次输入矩阵元素(系数矩阵：常系数矩阵\n'c rea
Fortran 高斯消元法
ROCK_LOTUS的博客
03-22 2647
@[TOC] Fortran 高斯消元法 Fortran 高斯消元法 最近是学习使用Fortran 95进行一些科学计算的代码编程，看了宋志叶老师所著《科学计算与工程》，磨练一些Fortran的编程技巧，用模块的方法重新编写了Fortran的Gauss消元法。 // An highlighted block //TriEq.f90 module tri_eq !-----------------...
高斯消元法（高斯·约当消元法）（浮点）
CaptainChen的博客
02-05 5366
高斯消元法，用于解多元一次方程（几乎类似模拟手动解方程）。 思路： 通过等式的乘除，把方程1的x1x1x_1系数a11a11a_{11}分别化为方程2~方程n的x1x1x_1系数，然后将方程2~方程n减去得到的新方程，从而消掉方程2~方程n中的x1x1x_1。接着用方程2的x2x2x_2继续把方程3~方程n中的x2x2x_2消掉…… 大概系数就成了这个样子↓ 举个例子： 一个...
fortran 高斯消元法 非并行版本
04-29
fortran 高斯消元法 非并行版本 可以通过修改消元部分代码成为HPF并行版本
高斯消元法Fortran程序
09-10
高斯消元法Fortran程序数值计算中的基本方法。
Fortran语言写的高斯消去法求解方程组
01-17
本代码用Fortran语言实现了高斯消元法，代码接单明了，已于学习
Fortran列主元高斯消元法
10-05
Fortran列主元高斯消元，希望能给大家帮助
高斯消元_fortran
weixin_44214857的博客
03-30 375
高斯消元___fortran版本 DIMENSION A(10,10),B(10),X(10) INTEGER N,K,I,J,MID,TEMP WRITE(*,*)"输入矩阵的阶数：" READ(*,*)N WRITE(*,*)"请输入每行的系数：" READ(*,*)((A(I,J),I=1,N),J=1,N) WRITE(*,*)"请输入右侧的值" READ(*,*)(B(I),I=1,
矩阵求逆 数值计算方法实验 数值方法实验
05-16
一.试验目的：练习用数值方法求逆矩阵。 二.实验内容：求下面矩阵的逆矩阵： .
高斯-约当（Gauss-Jordan）消元法——c++代码实现
zwz的学习之路
04-09 6557
具体算法的详细原理请参照此篇博客：高斯-约当（Gauss-Jordan）消元法下面是具体c++代码，不保证程序最优化，提供一个可行的程序，供大家改进，同时感谢大家提意见。——大神勿喷呀，我是一个小菜鸟~void Guss_Jordan(int n,double *a)//阶数n 系数矩阵a { double*a_temp = new double[n*n * 2];//a与单位矩阵的组合
高斯消元法 & 高斯-约当 (Gauss-Jordan) 消元法
03-10 9997
高斯消元法 & 高斯-约当 (Gauss-Jordan) 消元法   2010-05-24 18:02:10|  分类：控制理论 |  标签：|字号大中小 订阅 高斯消元法是求解线性方程组的常用方法，高斯约当消元法大家可能不是很熟悉。下面先介绍线性方程组和矩阵的一些基本概念与高斯消元法，然后着重介绍高斯约当消元法相对于高斯消元法的优势：程序简单（不需要回代），应用广泛（例
列选主元的高斯消元法的Fortran程序
Yangjing6545的博客
06-29 732
要用到之前发的解上三角矩阵和下三角矩阵方程的模块tri_eq.f90。 博客园代码不支持fortran格式。。。 1 module lina_gauss 2 !---------------------------------------------module comment 3 ! Author : Huang zc 4 ! Date : ...
高斯消元（Gaussian elimination）
热门推荐
努力中的老周的专栏
11-24 2万+
我们将分两个部分来说明高斯消去，第一部分是数学方面，第二个部分是如何用 C++ 来实现。 第一部分 数学知识 什么是高斯消去 高斯消元法（或译：高斯消去法），是线性代数规划中的一个算法，可用来为线性方程组求解。 高斯消元的目标是将矩阵变为上三角矩阵，例如，对应的矩阵为就是一个上三角矩阵（upper triangular matrix）。 对于一个线性方程组，我们可以写出两个矩阵（系数矩阵 coefficient matrix 和增广矩阵 Augmented Matrix），如下图所示。 .
C++使用雅可比迭代法(jacobi)和高斯赛德尔迭代法(G-S)解线性方程组
今天写代码了吗
06-04 5388
简言之迭代法的相关推导 迭代法的收敛性与谱半径雅可比迭代法： 高斯赛德尔迭代法：
线性代数之一：方程组与矩阵
zzulp的专栏
11-01 1万+
1 线性方程组 2 行阶梯形 3 矩阵算术 4 矩阵代数 5 初等矩阵
高斯-约旦消去法
qq_61959524的博客
05-05 837
高斯—约旦消去法
高斯消元(Java实现)
fuzekun的博客
11-14 1137
高斯消元，或者求解矩阵的秩，Java实现。
java读取txt代码和fortran冲突
最新发布
06-11
Java读取txt文件的代码和Fortran没有任何冲突，它们是两种完全不同的编程语言，各自有自己的语法和规则。...可以看出，Java和Fortran的读取txt文件的代码实现方式是不同的，但它们之间没有任何冲突。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值