packagelinear_equation;
importjava.util.Scanner;
/*使用高斯赛德尔迭代法求解线性方程组*/
publicclass Gauss_Seidel_Iterate {
    /*求下三角*/
    privatestatic float[][] find_lower(floatdata[][],intk){
        intlength=data.length;
        floatdata2[][]=newfloat[length][length];
        if(k>=0){
            for(inti=0;i<=length-k-1;i++){
                for(intj=0;j<=i+k;j++){
                    data2[i][j]=data[i][j];
                }
            }
            for(inti=length-k;i<length;i++){
                for(intj=0;j<length;j++){
                    data2[i][j]=data[i][j];
                }
            }
        }
        else{
            for(inti=-k;i<length;i++){
                for(intj=0;j<=i+k;j++){
                    data2[i][j]=data[i][j];
                }
            }
        }
        returndata2;
    }
    /*求原矩阵的负*/
    privatestatic float[][] opposite_matrix(float[][] data){
        intM=data.length;
        intN=data[0].length;
        floatdata_temp[][]=newfloat[M][N];
        for(inti=0;i<M;i++){
            for(intj=0;j<N;j++){
                data_temp[i][j]=-data[i][j];
            }
        }
        returndata_temp;
    }
    /*原矩阵去掉第i+1行第j+1列后的剩余矩阵*/
    privatestatic float[][] get_complement(float[][] data, inti, intj) {
        /* x和y为矩阵data的行数和列数 */
        intx = data.length;
        inty = data[0].length;
        /* data2为所求剩余矩阵 */
        floatdata2[][] = newfloat[x - 1][y - 1];
        for(intk = 0; k < x - 1; k++) {
            if(k < i) {
                for(intkk = 0; kk < y - 1; kk++) {
                    if(kk < j) {
                        data2[k][kk] = data[k][kk];
                    }else{
                        data2[k][kk] = data[k][kk + 1];
                    }
                }
            }else{
                for(intkk = 0; kk < y - 1; kk++) {
                    if(kk < j) {
                        data2[k][kk] = data[k + 1][kk];
                    }else{
                        data2[k][kk] = data[k + 1][kk + 1];
                    }
                }
            }
        }
        returndata2;
    }
    /* 计算矩阵行列式 */
    privatestatic float cal_det(float[][] data) {
        floatans=0;
        /*若为2*2的矩阵可直接求值并返回*/
        if(data[0].length==2){
             ans=data[0][0]*data[1][1]-data[0][1]*data[1][0];
        }
        else{
            for(inti=0;i<data[0].length;i++){
                /*若矩阵不为2*2那么需求出矩阵第一行代数余子式的和*/
                float[][] data_temp=get_complement(data, 0, i);
                if(i%2==0){
                    /*递归*/
                    ans=ans+data[0][i]*cal_det(data_temp);
                }
                else{
                    ans=ans-data[0][i]*cal_det(data_temp);
                }
            }
        }
        returnans;
    }
     
    /*计算矩阵的伴随矩阵*/
    privatestatic float[][] ajoint(float[][] data) {
        intM=data.length;
        intN=data[0].length;
        floatdata2[][]=newfloat[M][N];
        for(inti=0;i<M;i++){
            for(intj=0;j<N;j++){
            if((i+j)%2==0){
                data2[i][j]=cal_det(get_complement(data, i, j));
            }
            else{
                data2[i][j]=-cal_det(get_complement(data, i, j));
            }
            }
        }
         
        returntrans(data2);
         
    }
     
    /*转置矩阵*/
    privatestatic float [][]trans(float[][] data){
        inti=data.length;
        intj=data[0].length;
        float[][] data2=newfloat[j][i];
        for(intk2=0;k2<j;k2++){
            for(intk1=0;k1<i;k1++){
                data2[k2][k1]=data[k1][k2];
            }
        }
         
        /*将矩阵转置便可得到伴随矩阵*/
        returndata2;
         
    }
     
     
     
    /*求矩阵的逆，输入参数为原矩阵*/
    privatestatic float[][] inv(float[][] data){
        intM=data.length;
        intN=data[0].length;
        floatdata2[][]=newfloat[M][N];
        floatdet_val=cal_det(data);
        data2=ajoint(data);
        for(inti=0;i<M;i++){
            for(intj=0;j<N;j++){
                data2[i][j]=data2[i][j]/det_val;
            }
        }
         
        returndata2;
    }
    /*矩阵加法*/
    privatestatic float[][] matrix_add(float[][] data1,float[][] data2){
        intM=data1.length;
        intN=data1[0].length;
        floatdata[][]=newfloat[M][N];
        for(inti=0;i<M;i++){
            for(intj=0;j<N;j++){
                data[i][j]=data1[i][j]+data2[i][j];
            }
        }
        returndata;
    }
    /*矩阵相乘*/
    privatestatic float[][] multiply(float[][] data1,float[][] data2){
        intM=data1.length;
        intN=data1[0].length;
        intK=data2[0].length;
        float[][] data3=newfloat[M][K];
        for(inti=0;i<M;i++){
            for(intj=0;j<K;j++){
                for(intk=0;k<N;k++){
                    data3[i][j]+=data1[i][k]*data2[k][j];
                }
            }
        }
        returndata3;
    }
    /*输入参数为原矩阵和一个整数,该整数代表从对角线往上或往下平移的元素个数*/
    privatestatic float[][] find_upper(float[][] data,intk){
        intlength=data.length;
        intM=length-k;
        float[][] data2=newfloat[length][length];
        if(k>=0){
            for(inti=0;i<M;i++){
                for(intj=k;j<length;j++){
                    data2[i][j]=data[i][j];
                }
                k+=1;
            }
        }
        else{
            for(inti=0;i<-k;i++){
                for(intj=0;j<length;j++){
                    data2[i][j]=data[i][j];
                }
            }
            for(inti=-k;i<length;i++){
                for(intj=i+k;j<length;j++){
                    data2[i][j]=data[i][j];
                }
            }
        }
        returndata2;
    }
    /*m*n矩阵与n维向量的乘法*/
    privatestatic float[] multiply2(float[][] data1,float[] data2){
        intM=data1.length;
        intN=data1[0].length;
        float[] data3=newfloat[M];
        for(intk=0;k<M;k++){
                for(intj=0;j<N;j++){
                    data3[k]+=data1[k][j]*data2[j];
                }
        }
        returndata3;
    }
    /*向量加法*/
    privatestatic float[] matrix_add2(float[] data1,float[] data2){
        intM=data1.length;
        floatdata[]=newfloat[M];
        for(inti=0;i<M;i++){
                data[i]=data1[i]+data2[i];
        }
        returndata;
    }
    /*求两向量之差的二范数（用于检验误差）*/
    privatestatic double cal_error(float[] X1,float[] X2){
        intM=X1.length;
        doubletemp=0;
        for(inti=0;i<M;i++){
            temp+=Math.pow((X1[i]-X2[i]),2);
        }
        temp=Math.sqrt(temp);
        returntemp;
    }
    /*求矩阵的对角矩阵*/
    privatestatic float[][] find_diagnal(floatA[][]) {
        intm = A.length;
        intn = A[0].length;
        floatB[][] = newfloat[m][n];
        for(inti = 0; i < m; i++) {
            for(intj = 0; j < n; j++) {
                if(i == j) {
                    B[i][j] = A[i][j];
                }
            }
        }
        returnB;
    }
    /*高斯赛德尔迭代法*/
    privatestatic float[] Gauss_Seidel_method(float[][] A,float[] B,float[] X){
        floatD[][]=find_diagnal(A);
        floatL[][]=find_lower(A, -1);
        floatU[][]=find_upper(A, 1);
        floattemp1[][]=inv(matrix_add(D, L));
        floattemp2[][]=opposite_matrix(temp1);
        floatB0[][]=multiply(temp2, U);
        floatF[]=multiply2(temp1, B);
         
        returnmatrix_add2(multiply2(B0, X), F);
     
         
    }
     
    publicstatic void main(String[] args) {
        System.out.println("输入系数矩阵的行和列数：");
        Scanner scan=newScanner(System.in);
        intM=scan.nextInt();
        System.out.println("输入方程组右侧方程值的维度：");
        intK=scan.nextInt();
        if(M!=K){
            System.out.println("方程组个数和未知数个数不等！");
            System.exit(0);
        }
         
        System.out.println("输入系数矩阵：");
        float[][] A=newfloat[M][M];
        for(inti=0;i<M;i++){
            for(intj=0;j<M;j++){
                A[i][j]=scan.nextFloat();
            }
        }
         
        System.out.println("输入值向量");
        float[] B=newfloat[M];
        for(inti=0;i<M;i++){
            B[i]=scan.nextFloat();
        }
         
        System.out.println("输入初始迭代向量：");
        float[] X=newfloat[M];
        for(inti=0;i<M;i++){
            X[i]=scan.nextFloat();
        }
         
        System.out.println("输入误差限：");
        floater=scan.nextFloat();
        floattemp[]=newfloat[M];
        while(cal_error((temp=Gauss_Seidel_method(A, B, X)), X)>=er){
            X=temp;
        }
//      while(cal_error((temp=Gauss_Seidel_method(A, B, X)), X)>=er){
//          X=temp;
//         
//      }
        X=temp;
        System.out.println("高斯赛德尔计算得到的解向量为：");
        for(inti=0;i<M;i++){
            System.out.println(X[i]+" ");
        }
        System.out.println();
    }
}
原文：http://www.oschina.net/code/snippet_574827_39084

java实现高斯赛德尔算法解线性方程组相关推荐

  1. VQLS：变分量子算法解线性方程组

    复现的算法为VQLS算法,用于处理线性方程组Ax=bAx=bAx=b的问题. 这是一种变分量子算法,即用一个经典的优化器来训练一个含参的量子电路,整个算法的思路有些类似机器学习. 代码参考了qiski ...

  2. matlab sor解线性方程组,SOR算法解线性方程组的matlab程序

    编写用SOR 方法求解线性方程组Ax=B 的标准程序,并求下列方程组的解,并比较松弛因子取 1.0.1.25.1.5时所需迭代的次数. 可取初始向量 (0) (1,1,1) T =x ,迭 代终止条件 ...

  3. Leetcode算法Java全解答--37. 解数独

    Leetcode算法Java全解答–37. 解数独 文章目录 Leetcode算法Java全解答--37. 解数独 题目 想法 结果 总结 代码 我的答案 大佬们的答案 测试用例 其他 题目 编写一个 ...

  4. java大数运算详解【其三】大数乘法之平方算法之按位二次展开式算法

    目录 java大数运算详解[其一]大数加减法 java大数运算详解[其二]大数乘法 java大数运算详解[其三]大数乘法之平方算法之按位二次展开式算法 java大数运算详解[其四]大数乘法之平方算法之 ...

  5. Matlab_用高斯赛德尔(Gaoss-Seidel)迭代法解线性方程组

    1.程序代码 function x=Gauss(A,b,x0,ep,N) %用途:用高斯迭代法解线性方程组Ax=b %A为系数矩阵,b为右端向量,x0为初始向量(默认零向量) %ep为精度(1e-6) ...

  6. 4.6 W 字总结！Java 11—Java 17特性详解

    作者 | 民工哥技术之路 来源 | https://mp.weixin.qq.com/s/SVleHYFQeePNT7q67UoL4Q Java 11 特性详解 基于嵌套的访问控制 与 Java 语言 ...

  7. 动态规划算法解最长公共子序列LCS问题

    动态规划算法解LCS问题 作者 July 二零一零年十二月三十一日 本文参考:微软面试100题系列V0.1版第19.56题.算法导论.维基百科. 第一部分.什么是动态规划算法 ok,咱们先来了解下什么 ...

  8. java多线程学习-java.util.concurrent详解

    http://janeky.iteye.com/category/124727 java多线程学习-java.util.concurrent详解(一) Latch/Barrier 博客分类: java ...

  9. JAVA数据结构与算法【简单介绍】

    前几天去面一个大厂,面试官特别好,面试官说到,我们的学习不能本末倒置,数据结构和算法是程序的基础,如果数据结构你没有学好,你真正意义上不算会写代码.你的代码是各处粘贴,杂乱无章的. 由于现在大多用JA ...

最新文章

  1. java bufferedimage颜色_使用BufferedImage进行渐变色操作
  2. HtmlWebpackPlugin实现资源的自定义插入
  3. struts2官方 中文教程 系列一：创建一个struts2 web Application
  4. idea 查看一个类的子类_Java-05-多态、抽象类、接口和内部类
  5. win7如何修改dns服务器地址,Win7系统DNS怎么设置？Win7系统DNS设置方法
  6. java json 构造_json 构造和解析
  7. 【计算机网络】Socket
  8. 去掉input、textarea 的边框
  9. python postmessage 鼠标_SilkTest高级进阶系列7-用PostMessage模拟鼠标
  10. Yii --Command 任务处理
  11. win10字体安装_Win10操作系统下字体的安装教程（非常详细，适合新手DIY）
  12. 代理记账和专职会计哪个更适合企业？
  13. 外汇兑换人民币业务的居民
  14. 电驴emule使用教程
  15. windows多网卡叠加网速
  16. Java类和对象之对象引用之模拟手机功能
  17. hdu6441 Find Integer 求勾股数 费马大定理
  18. mysql区间算法_「五大常用算法」一文图解分治算法和思想
  19. android指南针闪退,互动课堂及视频闪退修复方案(KB3132372)
  20. 正则表达式、常用的方法、正则字符、定位符、转义字符、分组与反向、元素运动、元素左右运行、运动函数封装

热门文章

  1. linux驱动开发字符设备,linux驱动开发（三） 字符设备驱动框架
  2. centos7 mysql 5.6.38_centos7.4 安装mysql 5.6.38
  3. linux 屏幕输出 高亮_如何设置SecureCRT窗口输出代码关键字高亮设置
  4. 简明天线理论与设计应用_天线理论与设计笔记5--(宽带天线、口径天线)
  5. 相位展开matlab程序,[转载]全相位FFT算法的MATLAB程序
  6. 孙连伟 java_java(jsp)简单实现数据库学生信息的增删改查案例
  7. java 同步转并行_Java线程与并行编程(二)
  8. c++后台管理系统_【获奖案例】第三届全国医院物联网大会“中国医院物联网应用十大优秀案例”安徽医科大学第一附属医院手术室行为管理系统...
  9. 离职半年了，最近又开始被吐槽输出不够...
  10. 为什么面试官总喜欢问String？