四个版本的雅可比迭代

最新推荐文章于 2024-01-25 11:28:21 发布
最新推荐文章于 2024-01-25 11:28:21 发布
阅读量187 收藏 1
点赞数
文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fallen250/article/details/131764744
版权

一、基于阻塞通信版本


#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
#include <unistd.h>

#define N 8
#define T 2
#define SIZE N / 4

void print_rows(int, float [][N]);

int main(int argc, char *argv[])
{
    int rank, size;
    float rows[SIZE + 2][N], temp[SIZE + 2][N], tmp[2][N], gather[N][N];
    MPI_Status status;

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    for (int i = 0; i < SIZE + 2; i++)
        for (int j = 0; j < N; j++)
            rows[i][j] = temp[i][j] = 0;

    if (rank == 0)
    {
        for(int i = 0; i < N; i++)
            rows[1][i] = 8.0;
    }
    if (rank == 3)
	{
        for (int i = 0; i < N; i++)
		    rows[2][i] = 8.0;
    }

    for (int i = 1; i < SIZE + 1; i++)
    {
        rows[i][0] = 8.0;
        rows[i][N - 1] = 8.0;
    }

    for (int step = 0; step < T; step++)
    {
        if (rank < 3)
        {
            MPI_Send(&rows[SIZE][0], N, MPI_FLOAT, rank + 1, 0, MPI_COMM_WORLD);
        }
        if (rank > 0)
        {
            MPI_Recv(&rows[0][0], N, MPI_FLOAT, rank - 1, 0, MPI_COMM_WORLD, &status);
        }
        if (rank > 0)
        {
            MPI_Send(&rows[1][0], N, MPI_FLOAT, rank - 1, 1, MPI_COMM_WORLD);
        }
        if (rank < 3)
        {
            MPI_Recv(&rows[SIZE + 1][0], N, MPI_FLOAT, rank + 1, 1, MPI_COMM_WORLD, &status);
        }
	
        int begin_row = (0 == rank) ? 2 : 1;	
        int end_row = (3 == rank) ? 1 : 2;
        
        for (int i = begin_row; i <= end_row; i++)
            for (int j = 1; j < N - 1; j++)
                temp[i][j] = 0.25 * (rows[i][j - 1] + rows[i][j + 1] + rows[i - 1][j] + rows[i + 1][j]);
        
        for (int i = begin_row; i <= end_row; i++)
            for (int j = 1; j < N - 1; j++)
                rows[i][j] = temp[i][j];
        
        sleep(rank);
        print_rows(rank, rows);

        if (rank == 3)
            printf("\n");
    }

    for(int i = 1; i < SIZE + 1; i++)
        for(int j = 0; j < N; j++)
           tmp[i - 1][j] = rows[i][j];

    MPI_Gather(tmp, 16, MPI_FLOAT, gather, 16, MPI_FLOAT, 0, MPI_COMM_WORLD);

    sleep(1);
    if (rank == 0)
    {
        printf("迭代后结果\n");
        for(int i = 0; i < N; i++)
        {
            for(int j = 0; j < N; j++)
                printf("%.3f\t", gather[i][j]);
            printf("\n");
        }
    }

    MPI_Finalize();
    return 0;
}

void print_rows(int rank, float rows[][N])
{
    printf("Result in process %d:\n", rank);
    for (int i = 0; i < SIZE + 2; i++)
    {
        for (int j = 0; j < N; j++)
            printf("%1.3f\t", rows[i][j]);
        printf("\n");
    }
    MPI_Barrier(MPI_COMM_WORLD);
}

迭代两次后结果

优缺点： 

1、代码比较繁琐。
2、如果通信比较多，并且次序安排的有问题的话，存在可能死锁的可能性。

二、基于捆绑消息发送接收版本


#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
#include <unistd.h>

#define N 8
#define T 2
#define SIZE N / 4

void print_rows(int, float [][N]);

int main(int argc, char *argv[])
{
    int rank, size;
    float rows[SIZE + 2][N], temp[SIZE + 2][N], tmp[2][N], gather[N][N];
    MPI_Status status;

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    for (int i = 0; i < SIZE + 2; i++)
        for (int j = 0; j < N; j++)
            rows[i][j] = temp[i][j] = 0;

    if (rank == 0)
    {
        for (int i = 0; i < N; i++)
            rows[1][i] = 8.0;
    }
    if (rank == 3)
    {
        for (int i = 0; i < N; i++)
		    rows[2][i] = 8.0;
    }

    for (int i = 1; i < SIZE + 1; i++)
    {
        rows[i][0] = 8.0;
        rows[i][N - 1] = 8.0;
    }

    for (int step = 0; step < T; step++)
    {
        int up_proc_id   = (rank == 0) ? MPI_PROC_NULL : (rank - 1);
        int down_proc_id = (rank == 3) ? MPI_PROC_NULL : (rank + 1);

        MPI_Sendrecv(&rows[SIZE][0], N, MPI_FLOAT, down_proc_id, 0, &rows[0][0], N, MPI_FLOAT, up_proc_id, 0, MPI_COMM_WORLD, &status);
        MPI_Sendrecv(&rows[1][0], N, MPI_FLOAT, up_proc_id, 1, &rows[SIZE + 1][0], N, MPI_FLOAT, down_proc_id, 1, MPI_COMM_WORLD, &status);
        
        int begin_row = (0 == rank) ? 2 : 1;	
        int end_row = (3 == rank) ? 1 : 2;
            
        for (int i = begin_row; i <= end_row; i++)
            for (int j = 1; j < N - 1; j++)
                temp[i][j] = 0.25 * (rows[i][j - 1] + rows[i][j + 1] + rows[i - 1][j] + rows[i + 1][j]);

        for (int i = begin_row; i <= end_row; i++)
            for (int j = 1; j < N - 1; j++)
                rows[i][j] = temp[i][j];

        sleep(rank);
        print_rows(rank, rows);

        if (rank == 3)
            printf("\n");
    }

    for(int i = 1; i < SIZE + 1; i++)
        for(int j = 0; j < N; j++)
           tmp[i - 1][j] = rows[i][j];

    MPI_Gather(tmp, 16, MPI_FLOAT, gather, 16, MPI_FLOAT, 0, MPI_COMM_WORLD);

    sleep(1);
    if (rank == 0)
    {
        printf("迭代后结果\n");
        for(int i = 0; i < N; i++)
        {
            for(int j = 0; j < N; j++)
                printf("%.3f\t", gather[i][j]);
            printf("\n");
        }
    }

    MPI_Finalize();
    return 0;
}

void print_rows(int rank, float rows[][N])
{
    printf("Result in process %d:\n", rank);
    for (int i = 0; i < SIZE + 2; i++)
    {
        for (int j = 0; j < N; j++)
            printf("%1.3f\t", rows[i][j]);
        printf("\n");
    }
    MPI_Barrier(MPI_COMM_WORLD);
}

迭代两次后结果

优缺点：

1、引入了虚拟进程，简化了代码。
2、通过MPI自行维护消息发送与接收的次序，避免死锁的可能性。

三、基于非阻塞消息通信版本


#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
#include <unistd.h>

#define N 16 
#define SIZE N / 4
#define T 2

void print_rows(int, float [][N]);

int main(int argc, char *argv[])
{
    int rank, size;
    float rows[SIZE + 2][N], temp[SIZE + 2][N], tmp[4][N], gather[N][N];
    MPI_Status status;
    MPI_Request request[4];
    MPI_Status txstatus[4];

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    for (int i = 0; i < SIZE + 2; i++)
        for (int j = 0; j < N; j++)
            rows[i][j] = temp[i][j] = 0;

    if (rank == 0)
    {
        for (int i = 0; i < N; i++)
            rows[1][i] = 8.0;
    }

    if (rank == 3)
	{
        for (int i = 0; i < N; i++)
		    rows[SIZE][i] = 8.0;
    }

    for (int i = 1; i < SIZE + 1; i++)
    {
        rows[i][0] = 8.0;
        rows[i][N - 1] = 8.0;
    }

    int up_proc_id = (rank == 0) ? MPI_PROC_NULL : (rank - 1);
    int down_proc_id = (rank == 3) ? MPI_PROC_NULL : (rank + 1); 
    MPI_Sendrecv(&rows[SIZE][0], N, MPI_FLOAT, down_proc_id, 0, &rows[0][0], N, MPI_FLOAT, up_proc_id, 0, MPI_COMM_WORLD, &status);
    MPI_Sendrecv(&rows[1][0], N, MPI_FLOAT, up_proc_id, 1, &rows[SIZE + 1][0], N, MPI_FLOAT, down_proc_id, 1, MPI_COMM_WORLD, &status);

    for (int step = 0; step < T; step++)
    {
        if (rank == 0)
        {
            for (int i = 1; i < N - 1; i++)
                temp[SIZE][i] = 0.25 * (rows[SIZE][i - 1] + rows[SIZE][i + 1] + rows[SIZE - 1][i] + rows[SIZE + 1][i]);
        }
        else if (rank == 3)
        {
            for (int i = 1; i < N - 1; i++)
                temp[1][i] = 0.25 * (rows[1][i - 1] + rows[1][i + 1] + rows[0][i] + rows[2][i]); 
        }
        else
	    {
            for (int i = 1; i < N - 1; i++)
            {
                temp[1][i] = 0.25 * (rows[1][i - 1] + rows[1][i + 1] + rows[0][i] + rows[2][i]);
                temp[SIZE][i] = 0.25 * (rows[SIZE][i - 1] + rows[SIZE][i + 1] + rows[SIZE - 1][i] + rows[SIZE + 1][i]);
            }
	    }

        MPI_Isend(&temp[SIZE][0], N, MPI_FLOAT, down_proc_id, 0, MPI_COMM_WORLD, &request[0]);
        MPI_Irecv(&rows[0][0], N, MPI_FLOAT, up_proc_id, 0, MPI_COMM_WORLD, &request[1]);
        MPI_Isend(&temp[1][0], N, MPI_FLOAT, up_proc_id, 1, MPI_COMM_WORLD, &request[2]);
        MPI_Irecv(&rows[SIZE + 1][0], N, MPI_FLOAT, down_proc_id, 1, MPI_COMM_WORLD, &request[3]);

        int begin_row = 2;
        int end_row = SIZE - 1;
        for (int i = begin_row; i <= end_row; i++)
            for (int j = 1; j < N - 1; j++)
                temp[i][j] = 0.25 * (rows[i][j - 1] + rows[i][j + 1] + rows[i - 1][j] + rows[i + 1][j]);
            
        int begin = (0 == rank) ? 2 : 1;
        int end = (3 == rank) ? SIZE - 1: SIZE;
        for (int i = begin; i <= end; i++)	
            for (int j = 1; j < N - 1; j++)
                rows[i][j] = temp[i][j];
        
	    MPI_Waitall(4, &request[0], &txstatus[0]);

        sleep(rank); 
        print_rows(rank, rows);

        if (rank == 3)
            printf("\n");
    }

    for (int i = 1; i < SIZE + 1; i++)
        for (int j = 0; j < N; j++)
           tmp[i - 1][j] = rows[i][j];

    MPI_Gather(tmp, 64, MPI_FLOAT, gather, 64, MPI_FLOAT, 0, MPI_COMM_WORLD);

    sleep(1);
    if (rank == 0)
    {
        printf("迭代后结果\n");
        for(int i = 0; i < N; i++)
        {
            for(int j = 0; j < N; j++)
                printf("%.3f\t", gather[i][j]);
            printf("\n");
        }
    }

    MPI_Finalize();
    return 0;
}

void print_rows(int rank, float rows[][N])
{
    printf("Result in process %d:\n", rank);
    for (int i = 0; i < SIZE + 2; i++)
    {
        for (int j = 0; j < N; j++)
            printf("%1.3f\t", rows[i][j]);
        printf("\n");
    }
    MPI_Barrier(MPI_COMM_WORLD);
}

迭代两次后结果

优缺点：

1、优化性能，实现计算与通信的重叠。
2、整个流程复杂度高。

四、基于重复非阻塞消息通信版本


#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
#include <unistd.h>

#define N 16
#define T 2
#define SIZE N / 4

void print_rows(int, float [][N]);

int main(int argc, char *argv[])
{
    int rank, size;
    float rows[SIZE + 2][N], temp[SIZE + 2][N], tmp[4][N], gather[N][N];
    MPI_Status status;
    MPI_Request request[4];
    MPI_Status txstatus[4];

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    for (int i = 0; i < SIZE + 2; i++)
        for (int j = 0; j < N; j++)
            rows[i][j] = temp[i][j] = 0;

    if (rank == 0)
    {
        for (int i = 0; i < N; i++)
            rows[1][i] = 8.0;
    }
    if (rank == 3)
	{
        for (int i = 0; i < N; i++)
		    rows[SIZE][i] = 8.0;
    }

    for (int i = 1; i < SIZE + 1; i++)
    {
        rows[i][0] = 8.0;
        rows[i][N - 1] = 8.0;
    }

    int up_proc_id = (0 == rank) ? MPI_PROC_NULL : (rank - 1); 
    int down_proc_id = (3 == rank)? MPI_PROC_NULL : (rank + 1); 
    MPI_Sendrecv(&rows[SIZE][0], N, MPI_FLOAT, down_proc_id, 0, &rows[0][0], N, MPI_FLOAT, up_proc_id, 0, MPI_COMM_WORLD, &status);
    MPI_Sendrecv(&rows[1][0], N, MPI_FLOAT, up_proc_id, 1, &rows[SIZE + 1][0], N, MPI_FLOAT, down_proc_id, 1, MPI_COMM_WORLD, &status);

    MPI_Send_init(&temp[SIZE][0], N, MPI_FLOAT, down_proc_id, 0, MPI_COMM_WORLD, &request[0]);
    MPI_Recv_init(&rows[0][0], N, MPI_FLOAT, up_proc_id, 0, MPI_COMM_WORLD, &request[1]);
    MPI_Send_init(&temp[1][0], N, MPI_FLOAT, up_proc_id, 1, MPI_COMM_WORLD, &request[2]);
    MPI_Recv_init(&rows[SIZE + 1][0], N, MPI_FLOAT, down_proc_id, 1, MPI_COMM_WORLD, &request[3]);

    for (int step = 0; step < T; step++)
    {
        if (0 == rank)
        {
            for (int i = 1; i < N - 1; i++)
                temp[SIZE][i] = 0.25 * (rows[SIZE][i - 1] + rows[SIZE][i + 1] + rows[SIZE - 1][i] + rows[SIZE + 1][i]);
        }
        else if (3 == rank)
        {
            for (int i = 1; i < N - 1; i++)
                temp[1][i] = 0.25 * (rows[1][i - 1] + rows[1][i + 1] + rows[0][i] + rows[2][i]); 
        }
        else
        {
            for (int i = 1; i < N - 1; i++)
            {
                temp[1][i] = 0.25 * (rows[1][i - 1] + rows[1][i + 1] + rows[0][i] + rows[2][i]);
                temp[SIZE][i] = 0.25 * (rows[SIZE][i - 1] + rows[SIZE][i + 1] + rows[SIZE - 1][i] + rows[SIZE + 1][i]);
            }
        }
        
        MPI_Startall(4, &request[0]);

        int begin_row = 2;
        int end_row = SIZE - 1;
        for (int i = begin_row; i <= end_row; i++)
            for (int j = 1; j < N - 1; j++)
                temp[i][j] = 0.25 * (rows[i][j - 1] + rows[i][j + 1] + rows[i - 1][j] + rows[i + 1][j]);

        int begin = (0 == rank) ? 2 : 1;
        int end = (3 == rank) ? SIZE - 1 : SIZE;
        for (int i = begin; i <= end; i++)	
            for (int j = 1; j < N - 1; j++)
                rows[i][j] = temp[i][j];

        MPI_Waitall(4, &request[0], &txstatus[0]);

        sleep(rank); 
        print_rows(rank, rows);

        if (rank == 3)
            printf("\n");
    }

    for (int i = 0 ; i < 4; i++) MPI_Request_free(&request[i]);

    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Gather(&rows[1][0], 64, MPI_FLOAT, gather, 64, MPI_FLOAT, 0, MPI_COMM_WORLD);

    sleep(1);
    if (rank == 0)
    {
        printf("迭代后结果\n");
        for(int i = 0; i < N; i++)
        {
            for(int j = 0; j < N; j++)
                printf("%.3f\t", gather[i][j]);
            printf("\n");
        }
    }

    MPI_Finalize();
    return 0;
}

void print_rows(int rank, float rows[][N])
{
    printf("Result in process %d:\n", rank);
    for (int i = 0; i < SIZE + 2; i++)
    {
        for (int j = 0; j < N; j++)
            printf("%1.3f\t", rows[i][j]);
        printf("\n");
    }
    MPI_Barrier(MPI_COMM_WORLD);
}

迭代两次后结果

 优缺点：

1、优化通信，提前初始化通信。

板牙奇奇
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
关于雅可比迭代的Python实现
gongdiwudu的专栏
12-15 1万+
​雅克比迭代法就是众多迭代法中比较早且较简单的一种，其命名也是为纪念普鲁士著名数学家雅可比。雅克比迭代法的计算公式简单，每迭代一次只需计算一次矩阵和向量的乘法，且计算过程中原始矩阵A始终不变，比较容易进行计算。 雅可比迭代是数字解法，然而该方法是有一定条件，如果不能正确地辨别这些条件是不可能得到正确解的，本文将针对这种算法的原理进行介绍，和程序实现。 (称为雅可比迭代矩阵） 二、程序实现
3.4 迭代法
tang7mj的博客
04-20 1万+
雅可比迭代法、高斯-赛德尔迭代法和逐次超松弛迭代法都是解线性方程组的迭代方法，它们的重点和难点以及易错点如下：雅可比迭代法：重点：利用分量分离的思想，每次更新一个未知量。迭代次数取决于迭代精度和初值。难点和易错点：雅可比迭代法的收敛速度较慢。需要保证系数矩阵A是严格对角占优或严格对角占优加强条件。初始猜测值的选择对迭代的结果有很大影响。高斯-赛德尔迭代法：重点：利用分量分离的思想，每次更新一个未知量，同时使用前面已经更新过的未知量。
线性方程组迭代解法——雅可比（Jacobi）迭代法，Gauss-Seidel迭代法和超松弛（SOR）迭代法
篱落~~成殇~~
12-16 2万+
线性方程组迭代解法——雅可比（Jacobi）迭代法 1、算法思想 2、算法流程 3、matlab实现 function [x]=Jacobi(A,b,x0) %%%输入线性方程组系数矩阵A，右端列向量b和初始向量x0； %%%采用雅可比迭代法求解方程组的数值解； %%%输出数值解x。 [~,m]=size(A); A_diag=diag(A); A(1:m+1:end)=0; flag=1; x=x0; while flag for i=1:m x(i)=(b(i)-A(i,:)
雅可比高斯迭代法原理及其实际用法介绍举例（附C++代码）
qq_60811855的博客
07-19 7017
雅可比迭代法与高斯迭代法主要用于求解线性方程组，经过n次迭代收敛于精确值达到求解近似解的目的。本文忽视了复杂的证明过程，使读者可以更加有效的了解雅可比与高斯迭代算法的实际应用。...
Jacobi迭代法
步子哥的博客
01-02 1807
Jacobi迭代法是数值线性代数中的一种算法，用于求解形如Ax = b的线性方程组。这里，A是一个实数或复数矩阵，x是未知向量，b是已知向量。在LLM推理加速问题上的最新进展和Jacobi迭代法有关。故先复习下Jacobi迭代法。雅可比解码是Lookahead的初始版本，类似Jacobi iteration method的思想，采取一种逐步迭代的方式完成投机采样的过程，随机初始化后，每步迭代的输出作为下一步迭代的输入。
Jacobi迭代法 实验报告.docx
05-25
通过本次实验，不仅巩固了 Matlab 编程技能，还深化了对 Jacobi 迭代法的理解，认识到在实际工程问题中，通常会使用 Jacobi 迭代法的改进版本，例如 Gauß-Seidel 或SOR（Successive Over-Relaxation）方法，以提高...
牛顿迭代法、对分法、雅可比迭代、高斯赛德尔迭代
10-18
在数值计算领域，牛顿迭代法、对分法、雅可比迭代和高斯赛德尔迭代是四种常用且重要的算法，它们主要用于解决不同类型的数学问题。以下是对这些方法的详细阐述： 1. 牛顿迭代法（Newton's Iteration Method）： ...
雅可比迭代，二分法，增值寻根法，高斯法解方程组
06-03
下面将详细阐述这四个方法及其应用。 首先，雅可比迭代法是一种用于求解大型稀疏线性方程组的数值方法。在实际问题中，当方程组过大且部分元素为零时，直接求解会很耗时。雅可比迭代法通过将矩阵分解为对角部分和非...
Jacobi迭代法求解线性方程组以及Gauss-Seidel迭代法求解线性方程组的程序
10-17
这里，x_i^(k+1)是第i个元素在第k+1次迭代的值，d_i是D矩阵对角线上的元素，L和U与雅可比迭代法中的定义相同。与雅可比迭代法相比，Gauss-Seidel法在每次迭代中使用的是最新解的估计，而不是之前的解。 在C语言中...
迭代算法_迭代法——Matlab中实现_
10-04
4. **高斯-塞德尔迭代（Gauss-Seidel Iteration）**：高斯-塞德尔迭代是雅可比迭代的改进版本，它在每次迭代中使用当前已更新的元素，而不是前一次迭代的值，因此通常会更快收敛。在Matlab中，可以使用类似雅可比...
雅克比迭代法 c语言实现（计算方法）
10-24
调试通过，绝对好用，我们的计算方法实验，你值得拥有，c语言实现的！
雅可比迭代
11-06
雅可比迭代法，function tx=jacobi(A,b,imax,x0,tol) del=10^(-10); tx=[x0]; n=length(x0); for i=1:n dg=A(i,i); if abs(dg)<del disp; return end end for k=1:imax for i=1:n sm=b(i); for j=1:n if j~=i sm=sm-A(i,j)*x0(j); end end x(i)=sm/A(i,i); end tx=[tx,x]; if norm(x-x0)<tol return else x0=x; end end clear all clc A=[4 -1 0 -1 0 0;-1 4 -1 0 -1 0;0 -1 4 -1 0 -1;-1 0 -1 4 -1 0;0 -1 0 -1 4 -1;0 0 -1 0 -1 4]; b=[0 5 -2 5 -2 6]; x0=[0 0 0 0 0 0]; imax=100; tol=10^(-4); tx=jacobi(A,b,imax,x0,tol); for j=1:length(tx) fprintf('%d%f%f%f%f%f%f\n',j,tx(j,1),tx(j,2),tx(j,3),tx(j,4),tx(j,5),tx(j,6)); end function tx=jacobi(A,b,imax,x0,tol) del=10^(-10); tx=[x0]; n=length(x0); for i=1:n dg=A(i,i); if abs(dg)<del disp; return end end for k=1:imax for i=1:n sm=b(i); for j=1:n if j~=i sm=sm-A(i,j)*x0(j); end end x(i)=sm/A(i,i); end tx=[tx,x]; if norm(x-x0)<tol return else x0=x; end end clear all clc A=[4 -1 0 -1 0 0;-1 4 -1 0 -1 0;0 -1 4 -1 0 -1;-1 0 -1 4 -1 0;0 -1 0 -1 4 -1;0 0 -1 0 -1 4]; b=[0 5 -2 5 -2 6]; x0=[0 0 0 0 0 0]; imax=100; tol=10^(-4); tx=jacobi(A,b,imax,x0,tol); for j=1:length(tx) fprintf('%d%f%f%f%f%f%f\n',j,tx(j,1),tx(j,2),tx(j,3),tx(j,4),tx(j,5),tx(j,6)); end
雅可比迭代算法
03-28
matlab程序实现数值分析算法雅可比迭代，程序给出的是实例，在matlab中可直接运用。
雅可比迭代函数（matlab）
12-09
通用性函数供调用 代码只是函数，没有调用部分
雅克比(Jacobi)方法
zdk09hit的博客
01-02 9235
转载：https://www.cnblogs.com/ytxwzqin/p/9853781.html 雅克比(Jacobi)方法 可以用来求解协方差矩阵的特征值和特征向量。 雅可比方法(Jacobian method)求全积分的一种方法，把拉格朗阶查皮特方法推广到求n个自变量一阶非线性方程的全积分的方法称为雅可比方法。 雅克比迭代法的计算公式简单，每迭代一次只需计算一次矩阵和向量的乘法，且计算过程中原始矩阵A始终不变，比较容易并行计算。 考虑线性方程组Ax=b时，一般当A为低阶稠密矩阵时，用主元消去法解此
《数值分析》-- 雅可比迭代法、高斯—塞德尔迭代法
热门推荐
HG0724的博客
12-20 3万+
讲解了雅可比迭代法、高斯—塞德尔迭代法；以及收敛性的相关概念
C语言线性方程组求解：LU分解、雅可比迭代、高斯-赛德尔迭代
最新发布
jk_lovers的博客
01-25 1377
（注：该程序C和C++通用）我们知道在Matlab中，矩阵的求解是非常方便的，对于Ax = b，只需要做x = A \ b的运算就可以得到x的结果，然而对于C语言，我们就需要寻找一些算法来实现线性矩阵的求解。由于本学期刚学完数值分析，并且目前做的项目中刚好有需要求解线性方程组的需求，于是将求解线性方程组的三种方法（其实还有更多，我这里仅给出三种）：LU分解、雅可比迭代以及高斯-赛德尔迭代。这三个算法的基本原理就不过多赘述了，大家想进一步学习的可以网上搜，一大堆教程，而且原理也较为简单。
matlab中欠定方程组超定方程组_第6章 解线性方程组的迭代法(基于MATLAB)
weixin_39785814的博客
10-21 770
前面我们已经知道对于线性方程组，一般有两种数值解法：直接法和迭代法。直接法前面已经写过了，没看的同学可以移步阅读：直接法。本次主要讲述迭代法及其相应的MATLAB代码。考虑线性方程组 当 为低阶稠密阵时一般采取直接法进行求解。但是我们在工程技术中经常遇到的是一些大型稀疏矩阵方程组( 的阶数很大，但 元素较多，解PDE(Partial Differential Equation)时常遇到)，此...
雅可比迭代（Jocabi）
菜鸟进阶
03-14 6818
function x=jacobi_fun(A,b,n,x0,tol,N)%设置一个函数jacobi_fun其中A为线性方程组的系数矩阵，b为常数矩阵，n为未知量个数，x0为初值条件，tol为允许误差的终止条件，N为最大迭代次数 x=zeros(n,1);%设置x向量的个数 y=zeros(n,1);%设置经过变换后的常数矩阵个数 c=zeros(n,n);%设置经过变换后的迭代矩阵 k=0;%设置迭代次数初值为0 for i=1:n for j=1:n if i==j c(i,j)=0;%迭代矩阵的对角线元素全为0 end if i~=j c(i,j)=-A(i,j)/A(i,i);%迭代矩阵中不在对角线上面的元素用-A(i,j)/A(i,i)来计算 end for k=1:n y(k)=b(k)/A(k,k);%计算常数矩阵经过变换后的结果 end end end while k<N%设置最大的迭代次数 x=c*x0+y;%雅可比迭代格式x(k+1)=c*x(k)+y if norm(x-x0)<tol%迭代终止允许误差的条件，判断为向量的二范数 break; end x0=x;%为下一次迭代赋新的迭代值 k=k+1;%迭代一次k自增一次 end if k==N%如果迭代次数为N则判断迭代次数已经到达上限 disp('迭代次数已到达上限!'); end disp(['迭代次数 k=',num2str(k)])%正常情况输出迭代次数 end 优化简化这个代码并说明每行代码意义
06-13
这段代码实现了雅可比迭代法求解线性方程组 Ax=b，其中 A 为系数矩阵，b 为常数矩阵，n 为未知量个数，x0 为初值条件，tol 为允许误差的终止条件，N 为最大迭代次数。 下面是经过优化简化后的代码，以及每行代码的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值