计算方法(数值分析)实验：解线性方程组的迭代法 雅克比迭代法 高斯赛德尔迭代法 松弛迭代法实现 java

最新推荐文章于 2022-10-04 00:27:39 发布
最新推荐文章于 2022-10-04 00:27:39 发布
阅读量700 收藏 7
点赞数 1
分类专栏： 计算方法（数值分析） 文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46087822/article/details/122285627
版权
该博客文章展示了如何使用Java编程实现Jacobi、Gauss-Seidel和SOR迭代方法来解决线性方程组。通过输入矩阵A和向量b，程序会进行迭代计算并输出结果。文章包含详细的代码实现，包括矩阵运算和迭代过程。
摘要由CSDN通过智能技术生成

用Jacobi，Gauss-Seidel和松弛迭代方法求解线性方程组并编程实现。要求编写实验程序（语言不限），给出实验结果。

题目：

package com.code;

import java.util.Scanner;

public class main {

    public static void main(String[] args) {
//        int n;
//
//        Scanner s = new Scanner(System.in);
//        System.out.print("请输入矩阵长度：");
//        n = s.nextInt();
//
//        double[][] A = new double[n][n];
//        double[][] b = new double[n][1];
//        System.out.println("请输入矩阵A：");
//        for (int i = 0; i < n; i++) {
//            for (int j = 0; j < n; j++) {
//                A[i][j] = s.nextDouble();
//            }
//        }
//        System.out.println("请输入矩阵b：");
//        for (int i = 0; i < n; i++) {
//            b[i][0] = s.nextDouble();
//        }
//        double[][] A = {{10, -1, 0}, {-1,10,-2}, {0,-4,10}};
//        double[][] b = {{9}, {7}, {6}};
        double[][] A = {{1,2,-2}, {1,1,1}, {2,2,1}};
        double[][] b = {{1}, {2}, {3}};
//        double[][] A = {{-4, 1, 1, 1}, {1,-4, 1,1}, {1,1,-4,1},{1,1,1,-4}};
//        double[][] b = {{1}, {1}, {1},{1}};

//        jacoby(A,b);
        GaussSeidel(A,b);
//        Sor(A,b,1.3);
    }

    public static void jacoby(double[][] A, double[][] b){
        int n = A.length;
        double[][] D = new double[n][n];
        double[][] LU = new double[n][n];
        double[][] D_inverse = new double[n][n];
        double[][] B = new double[n][n];
        double x1[][] = new double[n][1];
        double x2[][] = new double[n][1];
        //初始化D
        for (int i = 0; i < n; i++) {
            D[i][i] = A[i][i];
        }
//        初始化L+U
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i == j){
                    LU[i][i] = 0;
                } else{
                    LU[i][j] = -A[i][j];
                }
            }
        }

        D_inverse = getInverseMatrix(D, n);
        B = getMultiplyMatrix(D_inverse,LU);
        double[][] f = getMultiplyMatrix(D_inverse, b);
//        print(B);
        for (int i = 0; i < n; i++) {
            x1[i][0] = 0;
        }
        boolean flag = true;
        int z = 0;
        while (flag){
            flag = false;
            x2 = getSumMatrix(getMultiplyMatrix(B,x1), f);
            z++;
            for (int i = 0; i < n; i++) {
                if (Math.abs(x2[i][0] - x1[i][0]) > 5e-6){
                    flag = true;
                }
            }
            System.out.println("迭代次数为：" + z + "  结果为：");
            print(x2);
            x1 = x2;
        }

    }

    public static void GaussSeidel(double[][] A, double[][] b){
        int n = A.length;
        double[][] DL = new double[n][n];
        double[][] U = new double[n][n];
        double[][] DL_inverse = new double[n][n];
        double[][] G = new double[n][n];
        double x1[][] = new double[n][1];
        double x2[][] = new double[n][1];

//        初始化D-L
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (j > i){
                    DL[i][j] = 0;
                } else{
                    DL[i][j] = A[i][j];
                }
            }
        }
        //初始化U
        for (int i = 0; i < n; i++) {
            for (int j = i+1; j < n; j++) {
                U[i][j] = -A[i][j];
            }
        }

        DL_inverse = getInverseMatrix(DL, n);
        G = getMultiplyMatrix(DL_inverse,U);
        double[][] f = getMultiplyMatrix(DL_inverse, b);
//        print(DL);
//        print(U);
//        print(DL_inverse);
//        print(G);
//        print(f);
        for (int i = 0; i < n; i++) {
            x1[i][0] = 0;
        }

        boolean flag = true;
        int z = 0;
        while (flag){
            flag = false;
            x2 = getSumMatrix(getMultiplyMatrix(G,x1), f);
            z++;
            for (int i = 0; i < n; i++) {
                if (Math.abs(x2[i][0] - x1[i][0]) > 5e-6){
                    flag = true;
                }
            }
            System.out.println("迭代次数为：" + z + "  结果为：");
            print(x2);
            x1 = x2;
        }

    }

    public static void Sor(double[][] A, double[][] b, double w){
        int n = A.length;
        double[][] DL = new double[n][n];
        double[][] U = new double[n][n];
        double[][] DL_inverse = new double[n][n];
        double[][] G = new double[n][n];
        double x1[][] = new double[n][1];
        double x2[][] = new double[n][1];
         System.out.println(n);
         print(DL);
         print(A);
//        初始化D-L
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (j > i){
                    DL[i][j] = 0;
                } else{
                    DL[i][j] = A[i][j];
                }
            }
        }
        //初始化U
        for (int i = 0; i < n; i++) {
            for (int j = i+1; j < n; j++) {
                U[i][j] = -A[i][j];
            }
        }

        DL_inverse = getInverseMatrix(DL, n);
        G = getMultiplyMatrix(DL_inverse,U);
        double[][] f = getMultiplyMatrix(DL_inverse, b);
        print(DL);
        print(U);
        print(DL_inverse);
        print(G);
        print(f);
        for (int i = 0; i < n; i++) {
            x1[i][0] = 0;
        }

        boolean flag = true;
        int z = 0;
        while (flag){
            flag = false;
            x2 = getSumMatrix(getMultiplyMatrix(G,x1), f);
            for (int i = 0; i < n; i++) {
                x2[i][0] = x2[i][0] * w + (1 - w) * x1[i][0];
            }
            z++;
            for (int i = 0; i < n; i++) {
                if (Math.abs(x2[i][0] - x1[i][0]) > 5e-6){
                    flag = true;
                }
            }
            System.out.println("迭代次数为：" + z + "  结果为：");
            print(x2);
            x1 = x2;
        }

    }

    public static double[][] getInverseMatrix(double[][] A, int n) {
        double[][] U = new double[n][n];
        double[][] L = new double[n][n];
        double[][] Uinv = new double[n][n];
        double[][] Linv = new double[n][n];
        int size = n;
        // fill 1 at L's diagonal
        for (int i = 0; i < size; i++) {
            L[i][i] = 1.0;
        }
        // calculate the U's first row
        for (int j = 0; j < size; j++) {
            U[0][j] = A[0][j];
        }
        // calculate the L's first column
        for (int i = 1; i < size; i++) {
            L[i][0] = A[i][0] / U[0][0];
        }
        // iterative calculation of other rows and columns
        for (int k = 1; k < size; k++) {
            // the k_th row of U
            for (int j = k; j < size; j++) {
                // sum(L_kt*U_tj),t
                double s = 0.0;
                for (int t = 0; t < k; t++) {
                    s += L[k][t] * U[t][j];
                }
                // U_kj = A_kj - s
                U[k][j] = A[k][j] - s;
            }
            // the k_th column of L
            for (int i = k; i < size; i++) {
                // sum(L_it*U_tk),t
                double s = 0.0;
                for (int t = 0; t < k; t++) {
                    s += L[i][t] * U[t][k];
                }
                // L_ik = (A_ik - s) / U_kk
                L[i][k] = (A[i][k] - s) / U[k][k];
            }
        }

        // calculate L_inv
        for (int j = 0; j < size; j++) {
            for (int i = j; i < size; i++) {
                if (i == j) Linv[i][j] = 1 / L[i][j];
                else if (i < j) Linv[i][j] = 0;
                else {
                    double s = 0.0;
                    for (int k = j; k < i; k++) {
                        s += L[i][k] * Linv[k][j];
                    }
                    Linv[i][j] = -Linv[j][j] * s;
                }
            }
        }

        // calculate U_inv
        for (int j = 0; j < size; j++) {
            for (int i = j; i >= 0; i--) {
                if (i == j) Uinv[i][j] = 1 / U[i][j];
                else if (i > j) Uinv[i][j] = 0;
                else {
                    double s = 0.0;
                    for (int k = i + 1; k <= j; k++) {
                        s += U[i][k] * Uinv[k][j];
                    }
                    Uinv[i][j] = -1 / U[i][i] * s;
                }
            }
        }

        double[][] inv = new double[n][n];
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                for (int k = 0; k < size; k++) {
                    inv[i][j] += Uinv[i][k] * Linv[k][j];
                }
            }
        }

//        print(L);
//        print(U);
//        print(Linv);
//        print(Uinv);

        return inv;
    }

    public static double[][] getMultiplyMatrix(double[][] a, double[][] b) {
        //当a的列数与矩阵b的行数不相等时，不能进行点乘，返回null
        if (a[0].length != b.length)
            return null;
        //c矩阵的行数y，与列数x
        int y = a.length;
        int x = b[0].length;
        double c[][] = new double[y][x];
        for (int i = 0; i < y; i++){
            for (int j = 0; j < x; j++){
                //c矩阵的第i行第j列所对应的数值，等于a矩阵的第i行分别乘以b矩阵的第j列之和
                for (int k = 0; k < b.length; k++){
                    c[i][j] += a[i][k] * b[k][j];
                }
            }
        }
        return c;
    }

    public static double[][] getSorMatrix(double[][] a, double[][] b, double[][] x1) {
        //当a的列数与矩阵b的行数不相等时，不能进行点乘，返回null
        if (a[0].length != b.length)
            return null;
        //c矩阵的行数y，与列数x
        int y = a.length;
        int x = b[0].length;
        double c[][] = new double[y][x];
        for (int i = 0; i < y; i++){
            for (int j = 0; j < x; j++){
                //c矩阵的第i行第j列所对应的数值，等于a矩阵的第i行分别乘以b矩阵的第j列之和
                for (int k = 0; k < b.length; k++){
                    c[i][j] += a[i][k] * b[k][j];
                }
                c[i][j] += x1[i][j];
            }
        }
        return c;
    }


    public static double[][] getSubMatrix(double a[][], double b[][]) {
        //当a的列数与矩阵b的行数不相等时，不能进行点乘，返回null
        if (a.length != b.length && a[0].length != b[0].length)
            return null;
        //c矩阵的行数y，与列数x
        int x = a.length;
        int y = a[0].length;
        double c[][] = new double[x][y];
        for (int i = 0; i < x; i++)
            for (int j = 0; j < y; j++)
                //c矩阵的第i行第j列所对应的数值，等于a矩阵的第i行分别乘以b矩阵的第j列之和
                c[i][j] = a[i][j] - b[i][j];
        return c;
    }
    public static double[][] getSumMatrix(double a[][], double b[][]) {
        //当a的列数与矩阵b的行数不相等时，不能进行点乘，返回null
        if (a.length != b.length && a[0].length != b[0].length)
            return null;
        //c矩阵的行数y，与列数x
        int x = a.length;
        int y = a[0].length;
        double c[][] = new double[x][y];
        for (int i = 0; i < x; i++)
            for (int j = 0; j < y; j++)
                //c矩阵的第i行第j列所对应的数值，等于a矩阵的第i行分别乘以b矩阵的第j列之和
                c[i][j] = a[i][j] + b[i][j];
        return c;
    }

    public static void print(double[][] M) {
        for (int i = 0; i < M.length; i++) {
            for (int j = 0; j < M[0].length; j++) {
                System.out.printf("%12.9f" ,M[i][j]);
            }
            System.out.println();
        }
        System.out.println();
    }

}

 

斑马还没睡着
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现SOR超松弛迭代法解线性方程组
10-05
本代码使用java实现SOR超松弛迭代法解线性方程组，使用者可根据自身需要进行修改
高斯赛德尔java,高斯-赛德尔迭代法
weixin_36170009的博客
03-28 358
#include #include #define N 4 /* N为方程组系数矩阵的阶数*/#define MAX_N 1000 /* 最大迭代次数*/#define eps 1e-6 /* 给定精度要求*/float a[N][N]={{1.5,0.5,2.5,-3},{6,0.6,0,-5},{1,1.2,14,1},{-3,-5,1,11.1}};/*输入被求解线性方程组*/float b...
（五）Richardson 迭代法
AlbertM的博客
10-04 3273
本文主要内容如下： 1. Richardson 迭代法 2. Richardson 迭代法的收敛条件 3. 算法实现与算例验证
Jacobi法、Gauss-Seidel法、超松弛法求解线性代数方程组
LengDanRan
04-25 1983
问题引入 利用计算机求解线性方程组，精度要求为ε=0.001\varepsilon=0.001ε=0.001： {10x1−x2−2x3=7.2−x1+10x2−2x3=8.3−x1−x2+5x3=4.2 \left\{\begin{array}{l}10x_1-x_2-2x_3=7.2\\-x_1+10x_2-2x_3=8.3\\-x_1-x_2+5x_3=4.2\end{array}\righ...
雅克比迭代——java实现
CANDY的博客
09-26 1266
有方程组： 用雅可比迭代法及赛德尔迭代法解此方程组 终止条件： 源代码： ** * @program: Seidel * @Package: PACKAGE_NAME * @Description: TODO * @author: Mr.John * @date: 2020/3/14 15:28 */ public class Seidel { public static void main(String[] args) { double x1=0, x2=0, x3=
实验解线性方程组的基本迭代法实验.pdf
最新发布
04-01
实验报告的主题是关于解线性方程组的基本迭代法，主要包括Jacobi迭代法、Gauss-Seidel迭代法和SOR迭代法。实验的目标在于深入理解这三种迭代方法，并通过编程实现来提高程序设计能力，同时通过解决实际问题掌握它们...
Jacobi-Iteration.rar_Jacobi c_Jacobi 迭代法 解线性方程_jacobi iteration_
09-22
雅克比迭代法，也称为Jacobi方法，是数值分析领域中解决大型稀疏线性方程组的一种重要算法，特别是在处理大型系统时，如在物理、工程、经济建模等领域。这一方法由德国数学家卡尔·威廉·雅克比在19世纪提出，其核心...
MATLAB雅克比迭代法（Jacobi method）和高斯-赛德尔迭代法（Gauss–Seidel method）求Ax=b
12-26
在数值分析领域，雅克比迭代法（Jacobi method）和高斯-赛德尔迭代法（Gauss–Seidel method）是求解大型线性系统Ax=b的有效算法，尤其是在计算机科学和工程计算中广泛使用。MATLAB作为一种强大的数学计算软件，提供...
MATLAB实现Jacobi 迭代法，Gauss-Seidel 迭代法，逐次超松弛迭代法，共轭梯度法
03-18
求解线性⽅方程组 Ax=b，其中 A 为 ...比较 Jacobi 迭代法、Gauss-Seidel 迭代法、逐次超松弛迭代法、 共轭梯度法与高斯消去法、列主元消去法的计算时间。改变逐次超松弛迭代法的松弛因⼦， 分析其对收敛速度的影响。
雅克比高斯迭代法解线性方程组
12-31
在本课程设计中，主题是使用雅克比迭代和高斯赛德尔迭代法来求解线性方程组。这两种迭代方法是数值分析领域中解决大型稀疏线性系统的重要工具，尤其适用于矩阵条件数较高或者无法直接求解的情况下。 雅克比迭代法...
Jacobi 和 Gauss-Seidel 方法：用于求解线性方程组的迭代方法-matlab开发
05-29
实现 Jacobi 和 Gauss-Seidel 方法的简单代码。 要使用，请按照屏幕上的说明进行操作。
jacobi:用Java语言编写的Jacobi方法计算器
05-05
雅各比 用Java语言编写的Jacobi方法计算器。 作为大学数学课的项目而创建。
解线性方程组的迭代法 数值计算方法实验 数值方法实验
05-16
一.试验目的：练习线性方程组的迭代解法。 二.实验内容：分别用雅可比（Jacobi）迭代法和高斯—塞德尔（Gauss—Seidel）迭代法求解下列线性方程组，且比较收敛速度，要求当 是迭代终止。
java实现雅可比算法解线性方程组
10-04
java实现雅可比算法解线性方程组，使用者可根据自身需要修改
数值方法雅克比迭代法
05-31
#include<stdio.h> #include<math.h> # define n 3 void main() { int i,j,k=1; float x[n]={0,0,0},m[n]={0,0,0},s[n],error=1; float a[n][n]={8,-3,2,4,11,-1,2,1,4},d[n]={20,33,12}; for(k=0;error>1e-6;k++) {error=0; for(i=0;i<n;i++)s[i]=x[i]; for(i=0;i<n;i++)m[i]=0; for(i=0;i<n;i++) for(j=0;j<n;j++) m[i]=m[i]-a[i][j]*x[j]; for(i=0;i<n;i++) {m[i]=m[i]+d[i]+a[i][i]*x[i]; m[i]=m[i]/a[i][i]; } for(i=0;i<n;i++) x[i]=m[i]; printf("X1=%f X2=%f X3=%f\n",x[0],x[1],x[2]); for(i=0;i<n;i++)error+=fabs(s[i]-x[i]); } printf("\niterative times:%d",k); }
MATLAB直接法和迭代法求解线性方程组
mamba_kitty的博客
09-05 1万+
用MATLAB来求解线性方程组，主要包括直接法和迭代法两类。直接法：用计算公式直接计算求出线性方程组解的方法。迭代法：用迭代公式通过迭代计算求出满足精度要求的线性方程组近似解的方法。（迭代法是一种逐次逼近线性方程组解的方法）
高斯赛德尔java_java实现高斯赛德尔算法解线性方程组
weixin_31785177的博客
02-16 436
package linear_equation;import java.util.Scanner;/*使用高斯赛德尔迭代法求解线性方程组*/public class Gauss_Seidel_Iterate {/*求下三角*/private static float[][] find_lower(float data[][],int k){int length=data.length;float ...
jacobi迭代法 java_数值分析5-用Jacobi迭代法和Gauss-Seidel迭代法求解线性方程组
weixin_29972227的博客
02-28 1040
《数值分析5-用Jacobi迭代法和Gauss-Seidel迭代法求解线性方程组》由会员分享，可在线阅读，更多相关《数值分析5-用Jacobi迭代法和Gauss-Seidel迭代法求解线性方程组(6页珍藏版)》请在人人文库网上搜索。1、作业六：分别编写用Jacobi迭代法和Gauss-Seidel迭代法求解线性方程组Ax=B的标准程序，并求下列方程组的解。可取初始向量 X(0) =(0，0，0)；...
计算方法-Jacobi（雅可比）迭代法
热门推荐
qq_44183524的博客
02-24 2万+
太累了，不想写太多说明了，看ppt看代码吧，推荐华东理工大学的慕课 链接：https://www.bilibili.com/video/av83437134 计算方法-Jacobi（雅可比）迭代法 针对上面的课堂作业，我写了下面的代码，运行成功 """ @Date:2020/2/24 @Author:indigoDeveloper @E-mail：changwenhan0530@gmai...
数值分析实验：线性方程组基本迭代法详解与Matlab实现
实验报告主要针对的是数值分析中的一个重要主题——线性方程组的基本迭代法。该实验的目的包括深入理解并掌握Jacobi迭代法、Gauss-Seidel迭代法和SOR（Successive Overrelaxation）迭代法，以及提升程序设计能力。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值