迭代法求解线性方程组(C++)

已于 2024-05-29 18:46:05 修改
阅读量1.7k 收藏 27
点赞数 19
分类专栏： 基于armadillo库的数值分析实践 文章标签： c++ 算法
于 2024-01-21 00:04:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61219098/article/details/135540896
版权

文章目录

尽管所有的线性方程组都可以通过Gauss消去法和LU分解法求解, 但是对于大型的稀疏线性代数方程组, 往往求解效率较低. 这时候常使用的求解算法是迭代法, 其基本形式为:

x ( k + 1 ) = F k ( x ( k ) , x ( k − 1 ) , ⋯   , x ( 0 ) ) , k = 0 , 1 , ⋯ \bm x^{(k+1)}=\bm F_k(\bm x^{(k)},\bm x^{(k-1)},\cdots,\bm x^{(0)}),\quad k=0,1,\cdots x(k+1)=Fk​(x(k),x(k−1),⋯,x(0)),k=0,1,⋯

若 x ( k + 1 ) \bm x^{(k+1)} x(k+1)只与 x ( k ) \bm x^{(k)} x(k)有关, 且 F k \bm F_k Fk​是线性的, 即

x ( k + 1 ) = B k x ( k ) + f k \bm x^{(k+1)}=\bm B_k\bm x^{(k)}+\bm f_k x(k+1)=Bk​x(k)+fk​

其中, B k ∈ R n × n \bm B_k\in\mathbb R^{n\times n} Bk​∈Rn×n, 称为单步线性迭代法, B k \bm B_k Bk​称为迭代矩阵. 若 B k \bm B_k Bk​与 f k \bm f_k fk​都与 k k k无关, 即

x ( k + 1 ) = B x ( k ) + f \bm x^{(k+1)}=\bm B\bm x^{(k)}+\bm f x(k+1)=Bx(k)+f

称为单步定常线性迭代法. 本文主要讨论这种类型的迭代法.

求解算法

Jacobi迭代法

设有线性方程组

A x = b \bm A\bm x=\bm b Ax=b

其中, A = ( a i j ) \bm A=(a_{ij}) A=(aij​)非奇异, 我们将 A \bm A A的对角线 D \bm D D, 上三角部分 U \bm U U, 下三角部分 L \bm L L分离, 即

A = L + D + U \bm A=\bm L+\bm D+\bm U A=L+D+U

若 D \bm D D非奇异, 我们可以将 L x \bm L\bm x Lx和 U x \bm U\bm x Ux移到方程的右端, 再将方程两端同时左乘 D − 1 \bm D^{-1} D−1, 得

x = − D − 1 ( L + U ) x + D − 1 b \bm x=-\bm D^{-1}(\bm L+\bm U)\bm x+\bm D^{-1}\bm b x=−D−1(L+U)x+D−1b

若我们取 B J : = − D − 1 ( L + U ) , f J : = D − 1 b \bm B_J:=-\bm D^{-1}(\bm L+\bm U),\bm f_J:=\bm D^{-1}\bm b BJ​:=−D−1(L+U),fJ​:=D−1b, 则有如下迭代公式

x ( k + 1 ) = B J x + f J \bm x^{(k+1)}=\bm B_J\bm x+\bm f_J x(k+1)=BJ​x+fJ​

上式被称为Jacobi迭代法. 因此, 我们可以将算法表示为如下伪代码:

Gauss-Seidel迭代法

若我们把Jacobi迭代法还原为方程组的形式, 我们有

x i ( k + 1 ) = 1 a i i ( b i − ∑ j = 1 i − 1 a i j x j ( k ) − ∑ j = i + 1 n a i j x j ( k ) ) , i = 1 , 2 , ⋯   , n x_i^{(k+1)}=\frac1{a_{ii}}(b_i-\sum_{j=1}^{i-1}a_{ij}x_j^{(k)}-\sum_{j=i+1}^{n}a_{ij}x_j^{(k)}),\quad i=1,2,\cdots,n xi(k+1)​=aii​1​(bi​−j=1∑i−1​aij​xj(k)​−j=i+1∑n​aij​xj(k)​),i=1,2,⋯,n

观察上式可知, 在实际计算 x i ( k + 1 ) x_i^{(k+1)} xi(k+1)​的时候, 分量 x 1 ( k + 1 ) , ⋯   , x i − 1 ( k + 1 ) x_1^{(k+1)},\cdots,x_{i-1}^{(k+1)} x1(k+1)​,⋯,xi−1(k+1)​已经算出, 可以将 x 1 ( k ) , ⋯   , x i − 1 ( k ) x_1^{(k)},\cdots,x_{i-1}^{(k)} x1(k)​,⋯,xi−1(k)​替换为 x 1 ( k + 1 ) , ⋯   , x i − 1 ( k + 1 ) x_1^{(k+1)},\cdots,x_{i-1}^{(k+1)} x1(k+1)​,⋯,xi−1(k+1)​, 这样每次迭代都可以用到当前最新的计算结果, 这就是Gauss-Seidel迭代法. 相应地, Gauss-Seidel迭代法也有矩阵形式:

x ( k + 1 ) = B G S x + f G S \bm x^{(k+1)}=\bm B_{GS}\bm x+\bm f_{GS} x(k+1)=BGS​x+fGS​

其中, B G S : = − ( D + L ) − 1 U , f G S : = ( D + L ) − 1 b \bm B_{GS}:=-(\bm D+\bm L)^{-1}\bm U,\bm f_{GS}:=(\bm D+\bm L)^{-1}\bm b BGS​:=−(D+L)−1U,fGS​:=(D+L)−1b. 同样地, Gauss-Seidel迭代法可表示为伪代码如下:

超松弛迭代法

将Gauss-Seidel迭代法和Jacobi迭代法作加权平均, 我们就得到了超松弛迭代法(又叫SOR法). 其中Gauss-Seidel迭代法的权重 ω \omega ω称为松弛因子.

同以上两种迭代法, 超松弛迭代法也可以表示为如下的矩阵形式

x ( k + 1 ) = B ω x + f ω \bm x^{(k+1)}=\bm B_\omega\bm x+\bm f_\omega x(k+1)=Bω​x+fω​

其中, B ω : = ( D + ω L ) − 1 ( ( 1 − ω ) D − ω U ) , f ω : = ω ( D + ω L ) − 1 b \bm B_\omega:=(\bm D+\omega\bm L)^{-1}((1-\omega)\bm D-\omega\bm U),\bm f_\omega:=\omega(\bm D+\omega\bm L)^{-1}\bm b Bω​:=(D+ωL)−1((1−ω)D−ωU),fω​:=ω(D+ωL)−1b. 同样地, 超松弛迭代法可表示为伪代码如下:

算法实现

准备工作

首先进行预处理如下:

#include <armadillo>
#include <vector>
#include <QFile>
#include <QString>
#include <string>
using namespace arma;
using namespace std;

为了方便写入向量, 编写一个向量导出函数.1

void write_vec(QFile &file, const vec &x)
{
    string s;
    for (auto &i : x)
        s += (to_string(i)) += ',';
    *(s.end() - 1) = '\n';
    file.write(s.c_str());
}

Jacobi迭代法

矩阵法

/*
 * Jacobi迭代法(矩阵法)
 * A:系数矩阵
 * b:常数向量
 * x:迭代初始向量
 * u:迭代过程
 * e:迭代精度
 */
void Jacobi_mat(const mat &A, const vec &b, vec &x, vector<vec> &u, const double &e = 1e-6)
{
    vec x1(x), b1(b.n_elem, 1, fill::none);
    u.push_back(x);
    mat A1(A.n_rows, A.n_cols, fill::none);
    for (unsigned i(0); i != x.n_rows; ++i)
    {
        if (abs(A.at(i, i)) < e)
            throw "对角线元素为零！";
        A1.at(i, i) = 0;
        x.at(i) = b1.at(i) = b.at(i) / A.at(i, i);
        for (unsigned j(0); j != A.n_cols; ++j)
            if (i != j)
                x.at(i) -= (A1.at(i, j) = A.at(i, j) / A.at(i, i)) * x1.at(j);
    }
    u.push_back(x);
    while (norm(x1 - x) > e)
    {
        x1 = x;
        u.push_back(x = b1 - A1 * x);
    }
}

分量法

/*
 * Jacobi迭代法(分量法)
 * A:系数矩阵
 * b:常数向量
 * x:迭代初始向量
 * u:迭代过程
 * e:迭代精度
 */
void Jacobi_ele(const mat &A, const vec &b, vec &x, vector<vec> &u, const double &e = 1e-6)
{
    vec x1(x), b1(b.n_elem, 1, fill::none);
    u.push_back(x);
    mat A1(A.n_rows, A.n_cols, fill::none);
    for (unsigned i(0); i != x.n_rows; ++i)
    {
        if (abs(A.at(i, i)) < e)
            throw "对角线元素为零！";
        x.at(i) = b1.at(i) = b.at(i) / A.at(i, i);
        for (unsigned j(0); j != A.n_cols; ++j)
            if (i != j)
                x.at(i) -= (A1.at(i, j) = A.at(i, j) / A.at(i, i)) * x1.at(j);
    }
    u.push_back(x);
    while (norm(x1 - x) > e)
    {
        x1 = x;
        for (unsigned i(0); i != x.n_rows; ++i)
        {
            x.at(i) = b1.at(i);
            for (unsigned j(0); j != A.n_cols; ++j)
                if (i != j)
                    x.at(i) -= A1.at(i, j) * x1.at(j);
        }
        u.push_back(x);
    }
}

/*
 * Jacobi迭代法(分量法)
 * A:系数矩阵
 * b:常数向量
 * x:迭代初始向量
 * p:迭代过程保存路径
 * e:迭代精度
 */
void Jacobi(const mat &A, const vec &b, vec &x, const QString &p, const double &e = 1e-6)
{
    QFile file(p);
    if (!file.open(QIODevice::WriteOnly))
        throw "文件保存失败！";
    vec x1(x), b1(b.n_elem, 1, fill::none);
    write_vec(file, x);
    mat A1(A.n_rows, A.n_cols, fill::none);
    for (unsigned i(0); i != x.n_rows; ++i)
    {
        if (abs(A.at(i, i)) < e)
            throw "对角线元素为零！";
        x.at(i) = b1.at(i) = b.at(i) / A.at(i, i);
        for (unsigned j(0); j != A.n_cols; ++j)
            if (i != j)
                x.at(i) -= (A1.at(i, j) = A.at(i, j) / A.at(i, i)) * x1.at(j);
    }
    write_vec(file, x);
    while (norm(x1 - x) > e)
    {
        x1 = x;
        for (unsigned i(0); i != x.n_rows; ++i)
        {
            x.at(i) = b1.at(i);
            for (unsigned j(0); j != A.n_cols; ++j)
                if (i != j)
                    x.at(i) -= A1.at(i, j) * x1.at(j);
        }
        write_vec(file, x);
    }
    file.close();
}

Gauss-Seidel迭代法

矩阵法

void Gauss_Seidel_mat(const mat &A, const vec &b, vec &x, vector<vec> &u, const double &e = 1e-6)
{
    mat T(inv(trimatl(A))), A1(T * trimatu(A, 1));
    vec b1(T * b), x1;
    u.clear();
    u.push_back(x);
    do
    {
        x1 = x;
        u.push_back(x = b1 - A1 * x);
    } while (norm(x - x1) > e);
}

分量法

/*
 * Gauss-Seidel迭代法(分量法)
 * A:系数矩阵
 * b:常数向量
 * x:迭代初始向量
 * u:迭代过程
 * e:迭代精度
 */
void Gauss_Seidel_ele(const mat &A, const vec &b, vec &x, vector<vec> &u, const double &e = 1e-6)
{
    vec x1(x), b1(b.n_elem, 1, fill::none);
    u.push_back(x);
    mat A1(A.n_rows, A.n_cols, fill::none);
    for (unsigned i(0); i != x.n_rows; ++i)
    {
        if (abs(A.at(i, i)) < e)
            throw "对角线元素为零！";
        x.at(i) = b1.at(i) = b.at(i) / A.at(i, i);
        unsigned j(-1);
        while (++j != i)
            x.at(i) -= (A1.at(i, j) = A.at(i, j) / A.at(i, i)) * x.at(j);
        while (++j != A.n_cols)
            x.at(i) -= (A1.at(i, j) = A.at(i, j) / A.at(i, i)) * x.at(j);
    }
    u.push_back(x);
    while (norm(x1 - x) > e)
    {
        x1 = x;
        for (unsigned i(0); i != x.n_rows; ++i)
        {
            x.at(i) = b1.at(i);
            unsigned j(-1);
            while (++j != i)
                x.at(i) -= A1.at(i, j) * x.at(j);
            while (++j != A.n_cols)
                x.at(i) -= A1.at(i, j) * x.at(j);
        }
        u.push_back(x);
    }
}

/*
 * Gauss-Seidel迭代法(分量法)
 * A:系数矩阵
 * b:常数向量
 * x:迭代初始向量
 * p:迭代过程保存路径
 * e:迭代精度
 */
void Gauss_Seidel(const mat &A, const vec &b, vec &x, const QString &p, const double &e = 1e-6)
{
    QFile file(p);
    if (!file.open(QIODevice::WriteOnly))
        throw "文件保存失败！";
    vec x1(x), b1(b.n_elem, 1, fill::none);
    write_vec(file, x);
    mat A1(A.n_rows, A.n_cols, fill::none);
    for (unsigned i(0); i != x.n_rows; ++i)
    {
        if (abs(A.at(i, i)) < e)
            throw "对角线元素为零！";
        x.at(i) = b1.at(i) = b.at(i) / A.at(i, i);
        unsigned j(-1);
        while (++j != i)
            x.at(i) -= (A1.at(i, j) = A.at(i, j) / A.at(i, i)) * x.at(j);
        while (++j != A.n_cols)
            x.at(i) -= (A1.at(i, j) = A.at(i, j) / A.at(i, i)) * x.at(j);
    }
    write_vec(file, x);
    while (norm(x1 - x) > e)
    {
        x1 = x;
        for (unsigned i(0); i != x.n_rows; ++i)
        {
            x.at(i) = b1.at(i);
            unsigned j(-1);
            while (++j != i)
                x.at(i) -= A1.at(i, j) * x.at(j);
            while (++j != A.n_cols)
                x.at(i) -= A1.at(i, j) * x.at(j);
        }
        write_vec(file, x);
    }
    file.close();
}

超松弛迭代法

矩阵法

/*
 * SOR法(矩阵法)
 * A:系数矩阵
 * b:常数向量
 * w:松弛因子
 * x:迭代初始向量
 * u:迭代过程
 * e:迭代精度
 */
void SOR_mat(const mat &A, const vec &b, const double &w, vec &x, vector<vec> &u, const double &e = 1e-6)
{
    mat L(trimatl(A, -1)), D(diagmat(A)), U(trimatu(A, 1)), T(inv(trimatl(w * L + D))), A1(T * ((1 - w) * D - w * U));
    vec b1(T * b * w), x1;
    u.clear();
    u.push_back(x);
    do
    {
        x1 = x;
        u.push_back(x = b1 + A1 * x);
    } while (norm(x - x1) > e);
}

分量法

/*
 * SOR法(分量法)
 * A:系数矩阵
 * b:常数向量
 * w:松弛因子
 * x:迭代初始向量
 * u:迭代过程
 * e:迭代精度
 */
void SOR_ele(const mat &A, const vec &b, const double &w, vec &x, vector<vec> &u, const double &e = 1e-6)
{
    double w1(1 - w);
    vec x1(x), b1(b.n_elem, 1, fill::none);
    u.push_back(x);
    mat A1(A.n_rows, A.n_cols, fill::none);
    for (unsigned i(0); i != x.n_rows; ++i)
    {
        if (abs(A.at(i, i)) < e)
            throw "对角线元素为零！";
        (x.at(i) *= w1) += b1.at(i) = w * b.at(i) / A.at(i, i);
        unsigned j(-1);
        while (++j != i)
            x.at(i) -= (A1.at(i, j) = w * A.at(i, j) / A.at(i, i)) * x.at(j);
        while (++j != A.n_cols)
            x.at(i) -= (A1.at(i, j) = w * A.at(i, j) / A.at(i, i)) * x.at(j);
    }
    u.push_back(x);
    while (norm(x1 - x) > e)
    {
        x1 = x;
        for (unsigned i(0); i != x.n_rows; ++i)
        {
            (x.at(i) *= w1) += b1.at(i);
            unsigned j(-1);
            while (++j != i)
                x.at(i) -= A1.at(i, j) * x.at(j);
            while (++j != A.n_cols)
                x.at(i) -= A1.at(i, j) * x.at(j);
        }
        u.push_back(x);
    }
}

/*
 * SOR法(分量法)
 * A:系数矩阵
 * b:常数向量
 * w:松弛因子
 * x:迭代初始向量
 * p:迭代过程保存路径
 * e:迭代精度
 */
void SOR(const mat &A, const vec &b, const double &w, vec &x, const QString &p, const double &e = 1e-6)
{
    QFile file(p);
    if (!file.open(QIODevice::WriteOnly))
        throw "文件保存失败！";
    double w1(1 - w);
    vec x1(x), b1(b.n_elem, 1, fill::none);
    write_vec(file, x);
    mat A1(A.n_rows, A.n_cols, fill::none);
    for (unsigned i(0); i != x.n_rows; ++i)
    {
        if (abs(A.at(i, i)) < e)
            throw "对角线元素为零！";
        (x.at(i) *= w1) += b1.at(i) = w * b.at(i) / A.at(i, i);
        unsigned j(-1);
        while (++j != i)
            x.at(i) -= (A1.at(i, j) = w * A.at(i, j) / A.at(i, i)) * x.at(j);
        while (++j != A.n_cols)
            x.at(i) -= (A1.at(i, j) = w * A.at(i, j) / A.at(i, i)) * x.at(j);
    }
    write_vec(file, x);
    while (norm(x1 - x) > e)
    {
        x1 = x;
        for (unsigned i(0); i != x.n_rows; ++i)
        {
            (x.at(i) *= w1) += b1.at(i);
            unsigned j(-1);
            while (++j != i)
                x.at(i) -= A1.at(i, j) * x.at(j);
            while (++j != A.n_cols)
                x.at(i) -= A1.at(i, j) * x.at(j);
        }
        write_vec(file, x);
    }
    file.close();
}

实例分析

例1

用迭代法求解线性方程组

( 8 1 2 8 7 2 4 9 9 ) x = ( 10 18 17 ) \begin{pmatrix} 8&1&2\\8&7&2\\4&9&9 \end{pmatrix}\bm x=\begin{pmatrix} 10\\18\\17 \end{pmatrix} ​884​179​229​ ​x= ​101817​ ​

选取初值 x 0 = ( 0 , 0 , 0 ) T \bm x_0=(0,0,0)^T x0​=(0,0,0)T, 代入程序并测量时间得解向量为 x = ( 1.0625 , 1.3333 , 0.0833 ) T \bm x=(1.0625,1.3333,0.0833)^T x=(1.0625,1.3333,0.0833)T, 运行时间见下表:

算法实现方式耗时( μ \mu μs)
Jacobi迭代法(分量法)0.0393829
Jacobi迭代法(矩阵法)0.0456848
Gauss-Seidel迭代法(分量法)0.00231934
Gauss-Seidel迭代法(矩阵法)0.00382996
SOR法(分量法)0.00256348
SOR法(矩阵法)0.00396729

其中, 超松弛迭代法的松弛因子取1.2. 由表可知, 矩阵法实现比分量法实现较慢, 但可读性更高, 这是因为矩阵法实现涉及到矩阵求逆运算, 耗时较多; 在迭代方法方面, Gauss-Seidel迭代法和超松弛迭代法较快, 而Jacobi迭代较慢.

例2

用迭代法求解线性方程组

{ 7 x 1 + x 2 + 2 x 3 = 10 x 1 + 8 x 2 + 2 x 3 = 8 2 x 1 + 2 x 2 + 9 x 3 = 6 \begin{cases} 7x_1+x_2+2x_3=10\\ x_1+8x_2+2x_3=8\\ 2x_1+2x_2+9x_3=6 \end{cases} ⎩ ⎨ ⎧​7x1​+x2​+2x3​=10x1​+8x2​+2x3​=82x1​+2x2​+9x3​=6​

取初值为 ( 0 , 0 , 0 ) T (0,0,0)^T (0,0,0)T, 利用Jacobi迭代法有迭代过程如下表:

k k k x 1 ( k ) x_1^{(k)} x1(k)​ x 2 ( k ) x_2^{(k)} x2(k)​ x 3 ( k ) x_3^{(k)} x3(k)​
00.0000000.0000000.000000
11.4285711.0000000.666667
21.0952380.6547620.126984
31.2987530.8313490.277778
41.2304420.7682110.193311
51.2635950.7978670.222521
61.2510130.7864200.208564
71.2566360.7914820.213904
81.2543870.7894450.211529
91.2553570.7903190.212482
101.2549600.7899600.212072
111.2551280.7901120.212240
121.2550580.7900490.212169
131.2550880.7900760.212198
141.2550750.7900640.212186
151.2550810.7900690.212191
161.2550780.7900670.212189
171.2550790.7900680.212190
181.2550790.7900680.212190

而利用Gauss-Seidel迭代法有迭代过程如下表:

k k k x 1 ( k ) x_1^{(k)} x1(k)​ x 2 ( k ) x_2^{(k)} x2(k)​ x 3 ( k ) x_3^{(k)} x3(k)​
00.0000000.0000000.000000
11.4285710.8214290.166667
21.2636050.8003830.208003
31.2548020.7911490.212011
41.2549760.7901250.212200
51.2550680.7900670.212192
61.2550780.7900670.212190
71.2550790.7900680.212190

由此可见, Gauss-Seidel迭代法在本例中收敛速度较快.

  1. 这里用了Qt的QFile, 也可以方便地改写为使用标准库的FILE或文件输出流. ↩︎

zsc_118
关注
专栏目录
迭代法 求解线性方程组
Divine_z的博客
11-10 1898
迭代法 求解线性方程组 （MATLAB) 统筹了 李庆扬《数值分析》第五版中关于求解Ax=b的四种常用迭代法 一码多用 Jacobi、Gauss-Seidel、SOR、SSOR四种迭代法 可以自行选择迭代方法，自定义精度，选择收敛判定方案 交互式软件般的体验 代码如下 cyc clear; %% 程序说明 % 迭代法求解Ax=b. 可选求解器模型 % A为n阶系数矩阵;b为常数项，err指定精度 % R为迭代矩阵B的谱半径，k为迭代步数，x为最终解 %% 输入端 while 1 A=input('请输入
线性方程组求解的几种常用方法-c++代码实现
热门推荐
zwz的学习之路
04-09 3万+
写在博客之前 代码可能比较杂乱无章，初学者，大神勿喷。 代码后会附上算法伪码，可以对照看看。 Doolittle直接分解算法算法伪码： A[n][n]—系数矩阵、b[n] —常数项矩阵 L[n][n]、U[n][n]、y[n]、x[n]—L、U矩阵与解向量Step1 L赋值：对角线元素赋值1，上三角元素赋值0； Step2 U赋值：下三角元素赋值为0； Step3 For
线性方程组的求解 c++
02-09
线性方程组的求解 ，c++程序，可以通过输入系数来求解线性方程组。
3元一次方程(牛顿迭代法求方程的根)
dd_zhouqian的专栏
07-15 4163
牛顿迭代方求方程根的方法自行查找
【更新】C语言:通过矩阵高斯消元解n元一次方程组
最新发布
qq_64516527的博客
11-19 510
根据高斯消元的完整原理进行编写。使用两根指针（注意是物理意义上的指针，比喻作用），一根从上往下扫描，记为指针A，另一根从下往上扫描，记为指针B，指针A遇到0就停下来，记住对应的函数A'，指针B遇到非0停下来，记录对应的函数B'。如果A'
C++实现线性方程组求解
08-06
用C/C++语言实现如下函数： 1. bool lu(double* a, int* pivot, int n);矩阵的LU分解。 假设数组anxn在内存中按行优先次序存放。此函数使用高斯列选主元消去法将其就地进行LU分解。pivot为输出参数，pivot[0,n) 中存放主元的位置排列。 函数成功时返回false，否则返回true。 2. bool guass(double const* lu, int const* p, double* b, int n);求线代数方程组的解 设矩阵Lunxn为某个矩阵anxn的LU分解，在内存中按行优先次序存放。p[0,n)为LU分解的主元排列。b为方程组Ax=b的右端向量。此函数计算方程组Ax=b的解，并将结果存放在数组b[0,n)中。 函数成功时返回false，否则返回true。 3. void qr(double* a, double* d, int n);矩阵的QR分解 假设数组anxn在内存中按行优先次序存放。此函数使用HouseHolder变换将其就地进行QR分解。 d为输出参数，d [0,n) 中存放QR分解的上三角对角线元素。 4. bool householder(double const*qr, double const*d, double*b, int n); 求线代数方程组的解 设矩阵qrnxn为某个矩阵anxn的QR分解，在内存中按行优先次序存放。d [0,n) 为QR分解的上三角对角线元素。b为方程组Ax=b的右端向量。 函数计算方程组Ax=b的解，并将结果存放在数组b[0,n)中。 函数成功时返回false，否则返回true。
线性方程组的求解（C++）
10-19 4055
1. 最佳求解方案Most efficient way to solve a system of linear equations求解形如 Ax=b 的最佳方式
解线性方程组的C++类库
01-19
解线性方程组的C++类库，能够解决大多数线性代数问题，比如矩阵计算，线性方程组的求解等
雅克比迭代法和高斯-赛德尔法解线性方程组(C++).docx
07-05
雅克比迭代法的基本思想是将线性方程组写成矩阵形式，然后通过迭代来求解。假设我们要解的线性方程组为AX=B，其中A是系数矩阵，X是未知向量，B是常数向量。雅克比迭代法的迭代公式为X^(k+1)=D^(-1)(B-AX^(k))，其中D...
迭代法解线性方程组的C++代码
03-14
迭代法是一种在数值分析中广泛使用的求解线性方程组的方法，特别是在计算机科学和工程领域。相较于直接方法，如高斯消元法或LU分解，迭代法在处理大规模问题时更加高效，尤其是在硬件资源有限的情况下。下面我们将...
C++编程解决线性方程组
09-06
利用C++编程解决线性方程组的问题，对于训练C++基本技能和思想非常有帮助
线性方程组求解（C++）
10-05
求线性方程组的解C++源代码。求出系数行列式的值，再根据克莱姆法则求解。（保证全过）
C++程序求解线性方程组
09-12
一个求解n阶线性方程组的小程序，非常实用。
c++线性方程组求解源代码 原创
11-08
c++线性方程组求解源代码c++线性方程组求解源代码
c++解线性方程组的几种方法
05-17
提供C++解线性方程组的方法，让你的学习不再是一个艰巨的问题！
牛顿迭代法求解非线性方程组_牛顿迭代法_非牛顿_
10-04
牛顿迭代法是一种高效..."牛顿迭代法求解非线性方程组.jpg" 可能是展示算法流程或结果的示意图，帮助理解算法工作原理。通过学习这段代码和图像，初学者可以深入理解牛顿迭代法的实现细节，并将其应用于实际问题中。
数值计算解线性方程组迭代方法——雅克比迭代法（附源程序）.rar
11-05
本资源包含了一个使用C++实现的雅克比迭代法求解线性方程组的源代码，通过结合提供的博客文章，我们可以深入理解这种方法的原理和应用。 雅克比迭代法，也称为局部迭代法，主要用于求解形如 Ax = b 的线性方程组，...
赛德尔迭代法求解线性方程组c++
09-13
高斯赛德尔迭代法是一种用于求解线性方程组的迭代方法。它是雅可比迭代法的改进版本，通过在计算第i+1行的解时使用第i行的解来加快收敛速度。 迭代过程如下： 1. 输入线性方程组的增广矩阵和初始迭代向量。 2. 设置...
迭代法求解线性方程组
Reborn Lee
07-07 1万+
一、迭代法的一般形式相关知识了解：向量序列的收敛性：向量序列收敛于某个向量，当且仅当该向量序列的每个元素都收敛于相应的向量的元素：矩阵序列的收敛性：矩阵序列收敛某个矩阵，当且仅当该矩阵序列的每个元素收敛于相应矩阵的相应元素；————————————————————————————————————————————————————迭代法的一般形式：提出问题：——————————————————————...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zsc_118

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值