关于雅克比迭代, 高斯塞德尔迭代以及SOR迭代的C++实现

最新推荐文章于 2024-01-21 00:04:10 发布
最新推荐文章于 2024-01-21 00:04:10 发布
阅读量1.7k 收藏 36
点赞数 10
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43773164/article/details/104661692
版权

文章目录


算法不难，只要理解Jacobi的算法另外两种就很简单了，因为他们都是建立在Jacobi迭代的基础上．
首先讲一下程序，主要是由输入功能，和迭代方式调用功能实现块构成的．

点击这里下载源码.
提取码：mlpb

程序变量

int m; //m*n的系数矩阵
int max_times;// z最大迭代次数
int times = 0;//当前迭代次数
//int mx_mis = 99999999;
string choice;//功能选择
double mis;//误差范围
double mtrx[sz][sz];//系数矩阵
double b[sz];//常数矩阵
double init[sz];//初始向量
double ans[sz];//答案
//double max_mis[sz];//

主程序

int main()
{
    input();

    func();

    return 0;
}

输入功能

这里就是输入计算需要的系数矩阵,常数矩阵等基本条件.

void  input()
{
    cout<<"请输入迭代方式(J,GS,SOR)"<<endl;
    cin>>choice;

    cout << "请输入m" << endl;
    cin >> m;

    cout << "请输入系数矩阵m*n(m)" << endl;
    for ( int i = 0; i < m; i++ )
    {
        for ( int j = 0; j < m; j++ )
        {
            cin >> mtrx[i][j];
        }
    }

    cout << "请输入常数矩阵b:" << endl;
    for ( int i = 0; i < m; i++ )
    {
        cin >> b[i];
    }

    cout << "请输入初始向量" << endl;
    for ( int i = 0; i < m; i++ )
    {
        cin >> init[i];
        ans[i] = init[i];
    }

    cout << "请输入最大迭代次数:" << endl;
    cin >> max_times;

//    cout << endl << "请输入最大误差:"<<endl;
//         cin>>mis;
}

输出功能

迭代结束后进行输出

void output()
{

    cout << "迭代" << times+1 << "次,答案是" << endl;
    for ( int i = 0; i < m; i++ )
    {
//        cout << init[i] << endl;
        printf ( "%.4f\t", init[i] );
    }
    printf ( "\n" );
}

迭代调用功能

为了main函数里干净点，把功能函数统统放进func里

void func()
{
    if(choice=="J")
        Jacobi();
    else if(choice=="GS")
        GS();
    else
        SOR();
}

Jacobi迭代

首先确立迭代截止条件，就是迭代次数达到所设（或及误差满足条件，但我这里么有实现）．然后在while里进行具体迭代．
形如:
[ 10 − 1 − 2 − 1 10 − 2 − 1 − 1 5 ] [ x 1 x 2 x 3 ] = [ 7.2 8.3 4.2 ] \left[ \begin{matrix} 10 & -1 & -2 \\ -1 & 10 & -2 \\ -1 & -1 & 5 \end{matrix} \right] \left[ \begin{matrix} x_1\\ x_2 \\ x_3 \end{matrix} \right] = \left[ \begin{matrix} 7.2\\ 8.3\\ 4.2 \end{matrix} \right] ⎣⎡​10−1−1​−110−1​−2−25​⎦⎤​⎣⎡​x1​x2​x3​​⎦⎤​=⎣⎡​7.28.34.2​⎦⎤​
这个矩阵．进行Jacobi迭代时，按照迭代格式
x i k + 1 = 1 a i i ( d i − ∑ j = 1 i − 1 a i j k − ∑ j = i + 1 n a i j k ) x_i^{k+1}= \frac {1} {a_{ii}} \left(d_i- \sum_{j=1}^{i-1}a_{ij}^{k}-\sum_{j=i+1}^{n}a_{ij}^k \right) xik+1​=aii​1​(di​−j=1∑i−1​aijk​−j=i+1∑n​aijk​)
需要先进行类似矩阵乘法的操作，将其求和并用 d i d_i di​减去，然后除 a i i a_{ii} aii​，得到的值就是 x i k + 1 x_i^{k+1} xik+1​．

void Jacobi()
{
    do
    {
        mx_mis = 0;
        //根据初始向量进行向量乘法．求出每一行对应的解
        //把结果放在ans中
        for ( int i = 0; i < m; i++ )
        {
            double sum = 0;

            for ( int j = 0; j < m; j++ )
            {
                if ( j != i )
                {
                    sum += init[j] * mtrx[i][j];
                }
            }
            ans[i] = ( b[i] - sum  ) / mtrx[i][i];
            //            if ( i > 0 )
            if ( fabs ( init[i] - ans[i] ) > mx_mis )
                mx_mis = fabs ( init[i] - ans[i] );
        }
        //迭代完成一次, 就更新一次init数组,以便下一次迭代
        for ( int i = 0; i < m; i++ )
        {
            init[i] = ans[i];
        }
//        mx_mis=max_mis[0];
//        for(int i=0;i<m;i++)
//        {
//            if(max_mis[i]>mx_mis)
//                mx_mis= max_mis[i];
//        }
        output();
    }
    while ( ( times++ < max_times ) && ( mis_range < mx_mis ) );
}

GS迭代

迭代格式是 x i k + 1 = 1 a i i ( d i − ∑ j = 1 i − 1 a i j k − ∑ j = i + 1 n a i j k + 1 ) x_i^{k+1}= \frac {1} {a_{ii}} \left(d_i- \sum_{j=1}^{i-1}a_{ij}^{k}-\sum_{j=i+1}^{n}a_{ij}^{k+1} \right) xik+1​=aii​1​(di​−j=1∑i−1​aijk​−j=i+1∑n​aijk+1​)
对比Jacobi迭代，在代码上的实现区别就是不需要ans数组暂存，直接将新的 x i k + 1 x_i^{k+1} xik+1​赋给init[i]．自然也不需要init和ans的同步．

void GS()
{
    double temp;
    do
    {
        mx_mis = 0;
        //根据初始向量进行向量乘法．求出每一行对应的解
        for ( int i = 0; i < m; i++ )
        {
            double sum = 0;
            for ( int j = 0; j < m; j++ )
            {
                if ( j != i )
                {
                    sum += init[j] * mtrx[i][j];
                }
            }
            temp = init[i];
            init[i] = ( b[i] - sum  ) / mtrx[i][i];
            if ( fabs ( init[i] - temp ) > mx_mis )
                mx_mis = fabs ( init[i] - temp );
        }
        output();
    }
    while ( (  times++ < max_times ) && ( mx_mis > mis_range ) );
}

SOR迭代

void SOR()
{
    double w;
    cout << "请输入松弛因子ｗ:" << endl;
    cin >> w;
    double temp;
    do
    {
        mx_mis = 0;
        //根据初始向量进行向量乘法．求出每一行对应的解
        for ( int i = 0; i < m; i++ )
        {
            double sum = 0;
            for ( int j = 0; j < m; j++ )
            {
                if ( j != i )
                {
                    sum += init[j] * mtrx[i][j];
                }
            }
            temp = init[i];
            init[i] = init[i] + w * ( ( b[i] - sum  ) / mtrx[i][i]  - init[i] );
            if ( fabs ( init[i] - temp ) > mx_mis )
                mx_mis = fabs ( init[i] - temp );
        }
        output();
    }while ( (  times++ < max_times ) && ( mx_mis > mis_range ) );
}

上面是注意分析，下面是源代码.
如有错误请多指正.

#include<iostream>
#include<math.h>
#define sz 10

using namespace std;

/*****************************
@Jacobi迭代解线性方程组
@author:jawi
@date:2020/03/03
@tip:本程序默认输入矩阵均为理想矩阵
*****************************/

void input();
void Jacobi();
void GS();
void SOR();
void func();
void output();

int m; //m*n的系数矩阵
int max_times;// z最大迭代次数
int times = 0;//当前迭代次数
double mx_mis = 0;//当前最大误差
string choice;//功能选择
double mis;//误差范围
double mtrx[sz][sz];//系数矩阵
double b[sz];//常数矩阵
double init[sz];//初始向量
double ans[sz];//答案
double mis_range;//最大误差范围

int main()
{
    input();

    func();

    return 0;
}

void func()
{
    if ( choice == "J" )
        Jacobi();
    else if ( choice == "GS" )
        GS();
    else
        SOR();
}

void  input()
{
    cout << "请输入迭代方式(J,GS,SOR)" << endl;
    cin >> choice;

    cout << "请输入m" << endl;
    cin >> m;

    cout << "请输入系数矩阵m*n(m)" << endl;
    for ( int i = 0; i < m; i++ )
    {
        for ( int j = 0; j < m; j++ )
        {
            cin >> mtrx[i][j];
        }
    }

    cout << "请输入常数矩阵b:" << endl;
    for ( int i = 0; i < m; i++ )
    {
        cin >> b[i];
    }

    cout << "请输入初始向量" << endl;
    for ( int i = 0; i < m; i++ )
    {
        cin >> init[i];
        ans[i] = init[i];
    }

    cout << "请输入最大迭代次数:" << endl;
    cin >> max_times;

    cout << "请输入最大误差范围:" << endl;
    cin >> mis_range;

//    cout << endl << "请输入最大误差:"<<endl;
//         cin>>mis;
}

void Jacobi()
{
    do
    {
        mx_mis = 0;
        //根据初始向量进行向量乘法．求出每一行对应的解
        //把结果放在ans中
        for ( int i = 0; i < m; i++ )
        {
            double sum = 0;

            for ( int j = 0; j < m; j++ )
            {
                if ( j != i )
                {
                    sum += init[j] * mtrx[i][j];
                }
            }
            ans[i] = ( b[i] - sum  ) / mtrx[i][i];
            //            if ( i > 0 )
            if ( fabs ( init[i] - ans[i] ) > mx_mis )
                mx_mis = fabs ( init[i] - ans[i] );
        }
        //迭代完成一次, 就更新一次init数组,以便下一次迭代
        for ( int i = 0; i < m; i++ )
        {
            init[i] = ans[i];
        }
//        mx_mis=max_mis[0];
//        for(int i=0;i<m;i++)
//        {
//            if(max_mis[i]>mx_mis)
//                mx_mis= max_mis[i];
//        }
        output();
    }
    while ( ( times++ < max_times ) && ( mis_range < mx_mis ) );
}

void GS()
{
    double temp;
    do
    {
        mx_mis = 0;
        //根据初始向量进行向量乘法．求出每一行对应的解
        for ( int i = 0; i < m; i++ )
        {
            double sum = 0;
            for ( int j = 0; j < m; j++ )
            {
                if ( j != i )
                {
                    sum += init[j] * mtrx[i][j];
                }
            }
            temp = init[i];
            init[i] = ( b[i] - sum  ) / mtrx[i][i];
            if ( fabs ( init[i] - temp ) > mx_mis )
                mx_mis = fabs ( init[i] - temp );
        }
        output();
    }
    while ( (  times++ < max_times ) && ( mx_mis > mis_range ) );
}

void SOR()
{
    double w;
    cout << "请输入松弛因子ｗ:" << endl;
    cin >> w;
    double temp;
    do
    {
        mx_mis = 0;
        //根据初始向量进行向量乘法．求出每一行对应的解
        for ( int i = 0; i < m; i++ )
        {
            double sum = 0;
            for ( int j = 0; j < m; j++ )
            {
                if ( j != i )
                {
                    sum += init[j] * mtrx[i][j];
                }
            }
            temp = init[i];
            init[i] = init[i] + w * ( ( b[i] - sum  ) / mtrx[i][i]  - init[i] );
            if ( fabs ( init[i] - temp ) > mx_mis )
                mx_mis = fabs ( init[i] - temp );
        }
        output();
    }while ( (  times++ < max_times ) && ( mx_mis > mis_range ) );
}

void output()
{

    cout << "迭代" << times+1 << "次,答案是" << endl;
    for ( int i = 0; i < m; i++ )
    {
//        cout << init[i] << endl;
        printf ( "%.4f\t", init[i] );
    }
    printf ( "\n" );
}
klaus08
关注
  • 10
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SOR迭代法实验报告c语言,数学实验“线性方程组的J-迭代,GS-迭代,SOR-迭代解法”实验报告(内含matlab程序代码).doc...
weixin_36445866的博客
05-25 800
西京学院数学软件实验任务书课程名称数学软件实验班级数0901学号0912020107姓名李亚强实验课题线性方程组的J-迭代，GS-迭代，SOR-迭代方法。实验目的熟悉线性方程组的J-迭代，GS-迭代，SOR-迭代方法。实验要求运用Matlab/C/C++/Java/Maple/Mathematica等其中一种语言完成。实验内容线性方程组的J-迭代；线性方程组的GS-迭代；线性方程组的SOR-迭代。...
用C++实现的高斯赛德尔迭代法
04-26
自己随便编编的 用C++实现的高斯赛德尔迭代法。 恳请大家批评指正！
Gauss-Seidel 迭代和SOR迭代的通用c++程序
04-02
数值计算方法中关于Gauss-Seidel 迭代和SOR迭代的通用c++程序
C++实现Jacbio和SOR迭代
08-20
本资源为一份实验报告，是C++实现Jacbio和SOR迭代，其中包括原理和代码，代码有注解
【数值分析】线性方程组的迭代方法，jacobi，高斯赛德尔GS，SOR
lafea的博客
01-02 1817
2024年1月1日#analysis。
逐次超松弛迭代法 ( SOR ) 的C++实现
m0_51864047的博客
12-16 4245
随机生成若干个 nnn 阶方阵与 nnn 阶向量构成 Ax=bAx=bAx=b 建议直接生成对称正定矩阵 取 0<ω<20<\omega<20<ω<2 的若干值进行收敛代数对比 用充分条件判断该矩阵 AAA 是否对 SOR 迭代法收敛 实现用 SOR 法解该方程组 与精确解对比并计算误差 首先生成一个对称正定矩阵。由对称阵的三角分解定理，先随机生成一个下三角矩阵 L，再生成一个元素均为正数的对角矩阵 DDD，计算 LDLTLDL^TLDLT 就可以得到一个对.
Gauss-Seidel迭代法的C++实现
qq_42373896的博客
10-29 5046
高斯赛德尔迭代法大家可以从网站上找到相关的公式推导，这里给出它的C++算法实现和运行的结果。 #include<iostream> #include<math.h> using namespace std; int n; //定义全局变量 double a[100][100], b[100], x[100][100]; double e; void input_fun
使用迭代法（雅可比Jacobi与高斯-赛德尔Gausss-Seidel迭代法）和直接求解法（消元法）求解线性方程组（C++）
Huanyuaner的博客
10-27 3565
分别使用迭代法（Jacobi与Gausss-Seidel迭代法）和直接求解法（消元法）求解线性方程组： 要求：使误差不超过。
高斯-赛德尔迭代算法(C++实现)
热门推荐
qq_39559641的博客
07-15 1万+
问题描述输入：系数矩阵A，最大迭代次数N，初始向量，误差限e输出：解向量基本公式流程图算法实现#include &lt;iostream&gt; #include &lt;iomanip&gt; using namespace std; //定义系数矩阵 double a[50][50] = {0}; //定义x1解的数组 double rootX1[100]; //定义x2解的数组 doub...
C++使用雅可比迭代法(jacobi)和高斯赛德尔迭代法(G-S)解线性方程组
今天写代码了吗
06-04 6028
简言之迭代法的相关推导 迭代法的收敛性与谱半径雅可比迭代法： 高斯赛德尔迭代法：
雅克比迭代+高斯迭代+SOR迭代法Matlab程序
04-03
本主题涉及三种迭代方法：雅克比迭代、高斯迭代以及松弛法（SOR）迭代，并提供了相应的Matlab程序实现。这些方法广泛应用于科学计算、工程问题和数据分析中。 首先，雅克比迭代（Jacobi Iteration）是一种基于矩阵...
利用Python，实现雅克比(Jacobi)迭代法以及高斯-塞德尔(G-S)迭代法【矩阵形式】
12-20
利用Python，实现雅克比(Jacobi)迭代法以及高斯-塞德尔(G-S)迭代法【矩阵形式】 本文讲解使用Jacobi迭代和G-S迭代算法求解方程组的Python代码实现，同时涉及算法的原理阐述。 文章目录【Jacobi算法原理】【Jacobi的...
iteration.rar_gauss-seidel sor_正定矩阵_雅克比矩阵_雅克比迭代_高斯迭代
07-15
这里我们主要探讨的是"高斯-塞德尔迭代"（Gauss-Seidel Iteration）、"SOR迭代"（Successive Over-Relaxation）以及与它们相关的"正定矩阵"和"雅克比矩阵"的概念，以及雅克比迭代。 首先，让我们从"高斯-塞德尔迭代...
xianxingfangcheng.rar_方程 迭代_迭代高斯_雅克比迭代
07-14
有雅克比迭代法解线性方程和用高斯迭代法解线性方程
雅克比迭代法和高斯-赛德尔法解线性方程组(C++).docx
07-05
下面是一个使用C++语言实现雅克比迭代法和高斯-赛德尔法的示例代码： ```cpp // 雅克比迭代法 int main(){ int m,n,i,j,times=0,mtimes; double s,sum,max; cout请输入系数矩阵行数 m、列数 n："; cin>>m>>n; ...
松弛因子对SOR法收敛速度的影响之C++实现
www.v5qq.com的技术博客
07-28 910
一、问题描述 用SOR法求解方程组Ax=b, 其中 要求程序中不存系数矩阵A,分别对不同的阶数取w=1.1, 1.2, ...,1.9进行迭代，记录近似解x(k)达到||x(k)-x(k-1)||&lt;10-6时所用的迭代次数k，观察松弛因子对收敛速度的影响，并观察当w &lt;= 0或 w&gt;=2会有什么影响？ 二、计算结果与分析 (1) 在收敛标准||x(k)-x(k-1)||&lt...
【C++】高斯消元法、迭代法，线性方程组求解作业
blucod的博客
04-12 2356
文章目录线性方程组基本概念3种特殊解高斯消元法 线性方程组 基本概念 线性方程组：AX=bAX=bAX=b， 其中， A=[aii]n×n=[a11a12...a1na21a22...a2n............an1an2...ann]A=[a_{ii}]_{n×n}=\begin{bmatrix} a_{11}&a_{12}&...&a_{1n}\\ a_{21}&a_{22}&...&a_{2n}\\...&...&...&..
迭代法求解线性方程组(C++)
最新发布
m0_61219098的博客
01-21 1527
xk1Fk​xkxk−1⋯x0k01⋯若xk1只与xk有关, 且Fk​是线性的, 即xk1Bk​xkfk​其中,Bk​∈Rn×n, 称为单步线性迭代法,Bk​称为迭代矩阵. 若Bk​与fk​都与k无关, 即xk1Bxkf称为单步定常线性迭代法. 本文主要讨论这种类型的迭代法.
高斯赛德尔迭代与雅克比迭代的比较
05-23
高斯赛德尔迭代和雅克比迭代都是求解线性方程组的迭代方法。它们的区别在于迭代的方式不同。 1. 高斯赛德尔迭代 高斯赛德尔迭代是按照顺序，每次使用已知的最新的元素来更新未知元素。具体来说，对于 Ax=b 这个线性方程组，高斯赛德尔迭代的迭代公式为： $$ x_i^{(k+1)} = \frac{1}{a_{ii}}(b_i - \sum_{j=1}^{i-1}a_{ij}x_j^{(k+1)} - \sum_{j=i+1}^{n}a_{ij}x_j^{(k)}) $$ 其中，$i=1,2,\cdots,n$，$k$ 为迭代次数，$x_i^{(k+1)}$ 表示第 $k+1$ 次迭代后第 $i$ 个未知数的值，$a_{ij}$ 表示矩阵 $A$ 的第 $i$ 行第 $j$ 列元素，$b_i$ 表示向量 $b$ 的第 $i$ 个元素。 高斯赛德尔迭代需要从 $x_i^{(k)}$ 开始迭代，当 $i=1$ 时，使用已知的 $x_2^{(k)},x_3^{(k)},\cdots,x_n^{(k)}$ 来计算 $x_1^{(k+1)}$；当 $i=2$ 时，使用已知的 $x_1^{(k+1)},x_3^{(k)},\cdots,x_n^{(k)}$ 来计算 $x_2^{(k+1)}$；以此类推。 2. 雅克比迭代 雅克比迭代是同时更新所有未知元素。具体来说，对于 Ax=b 这个线性方程组，雅克比迭代的迭代公式为： $$ x_i^{(k+1)} = \frac{1}{a_{ii}}(b_i - \sum_{j=1,j\neq i}^{n}a_{ij}x_j^{(k)}) $$ 其中，$i=1,2,\cdots,n$，$k$ 为迭代次数，$x_i^{(k+1)}$ 表示第 $k+1$ 次迭代后第 $i$ 个未知数的值，$a_{ij}$ 表示矩阵 $A$ 的第 $i$ 行第 $j$ 列元素，$b_i$ 表示向量 $b$ 的第 $i$ 个元素。 雅克比迭代需要从 $x_i^{(k)}$ 开始迭代，当 $i=1$ 时，使用已知的 $x_1^{(k)},x_2^{(k)},\cdots,x_n^{(k)}$ 来计算 $x_1^{(k+1)}$；当 $i=2$ 时，使用已知的 $x_1^{(k+1)},x_2^{(k)},\cdots,x_n^{(k)}$ 来计算 $x_2^{(k+1)}$；以此类推。 两种方法的主要区别在于更新未知元素的顺序不同。高斯赛德尔迭代每次只更新一个未知元素，但是每次更新后可以马上使用最新的值来更新下一个未知元素，所以收敛速度比较快。而雅克比迭代每次更新所有未知元素，但是需要等到所有未知元素的值都更新完毕后才能使用最新的值来更新下一次迭代，所以收敛速度比较慢。但是，雅克比迭代可以并行计算，所以适用于多核处理器等并行计算平台。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值