Implementation of iterative method for linear equations

The theory part has been introduced in detail before

Iterative solution theory of linear equations

Here are $3\times 3$ Matrix as the iterative solution of coefficient matrix python Realization

1. Jacobian iteration

The solution equation is $A\vec{x}=\vec{b}$, The specific values are as follows
$$A=\left[\begin{array}{ccc}5& 2& 1\\ -1& 4& 2\\ 2& -3& 10\end{array}\right]\vec{b}=\left[\begin{array}{c}-12\\ 20\\ 3\end{array}\right]$$
The symbols in the code are the same as those in the derivation , The specific meaning is as follows
$$\{\begin{array}{l}{\vec{x}}_{k+1}=B{\vec{x}}_k+\vec{f}\\ B=D^{-1}(L+U)\\ \vec{f}=D^{-1}\vec{b}\end{array}$$

import numpy as np

ERROR = 0.001
A = np.array([[5, 2, 1],
     [-1, 4, 2],
     [2, -3, 10]])
b = np.array([[-12], [20], [3]])

m, n = np.shape(A)
D = np.mat(np.zeros((m, n)))
L = np.mat(np.zeros((m, n)))
U = np.mat(np.zeros((m, n)))

for i in range(m):
    for j in range(n):
        if i == j:
            D[i, j] = A[i, j]
        if i < j:
            L[i, j] = -A[i, j]
        if i > j:
            U[i, j] = -A[i, j]

x0 = np.array(np.zeros((m, 1)))
xk = np.array(np.zeros((m, 1)))

B = np.dot(D.I, (L + U))
f = np.dot(D.I, b)

print("B:", B)
print("f:", f)

iter_time = 1
xk = np.dot(B, x0) + f
while(np.linalg.norm((xk - x0)) >= ERROR):
    iter_time += 1
    print(xk)
    x0 = xk
    xk = np.dot(B, xk) + f

print("The iteration time: %d" %iter_time)

In the running results, you can see that the total number of iterations 14 Time , Intermediate process output is omitted , Only the last two vectors are displayed $\vec{x}$ Iterative results of

[[-4.00122406]
 [ 3.00000859]
 [ 2.00098719]]
[[-4.00020088]
 [ 2.99920039]
 [ 2.00024739]]
The iteration time: 14

2. G-S Iterative method

The solution equation is $A\vec{x}=\vec{b}$, The specific values are as follows
$$A=\left[\begin{array}{ccc}5& 2& 1\\ -1& 4& 2\\ 2& -3& 10\end{array}\right]\vec{b}=\left[\begin{array}{c}-12\\ 20\\ 3\end{array}\right]$$
The symbols in the code are the same as those in the derivation , The specific meaning is as follows
$$\{\begin{array}{l}{\vec{x}}_{k+1}=B{\vec{x}}_k+\vec{f}\\ B=(D-L{)}^{-1}U\\ \vec{f}=(D-L{)}^{-1}\vec{b}\end{array}$$

import numpy as np

ERROR = 0.001
A = np.array([[5, 2, 1],
     [-1, 4, 2],
     [2, -3, 10]])
b = np.array([[-12], [20], [3]])

m, n = np.shape(A)
D = np.mat(np.zeros((m, n)))
L = np.mat(np.zeros((m, n)))
U = np.mat(np.zeros((m, n)))

for i in range(m):
    for j in range(n):
        if i == j:
            D[i, j] = A[i, j]
        if i < j:
            L[i, j] = -A[i, j]
        if i > j:
            U[i, j] = -A[i, j]
            
x0 = np.array(np.zeros((m, 1)))
xk = np.array(np.zeros((m, 1)))

B = np.dot((D - L).I, U)
f = np.dot((D - L).I, b)

print("B:", B)
print("f:", f)

iter_time = 1
xk = np.dot(B, x0) + f
while(np.linalg.norm((xk - x0)) >= ERROR):
    iter_time += 1
    print(xk)
    x0 = xk
    xk = np.dot(B, xk) + f

print("The iteration time: %d" %iter_time)

In the running results, you can see that the total number of iterations 7 Time , It shows that the convergence speed of bijacobi iterative method is faster . Intermediate process output is omitted , Only the last two vectors are displayed $\vec{x}$ Iterative results of

[[-4.00004   ]
 [ 3.00207406]
 [ 1.99605188]]
[[-3.999996  ]
 [ 2.99967489]
 [ 2.00063022]]
The iteration time: 7

3. Successive over relaxation iterative method （SOR）

The solution equation is $A\vec{x}=\vec{b}$, The specific values are as follows
$$A=\left[\begin{array}{ccc}5& 2& 1\\ -1& 4& 2\\ 2& -3& 10\end{array}\right]\vec{b}=\left[\begin{array}{c}-12\\ 20\\ 3\end{array}\right]$$
The symbols in the code are the same as those in the derivation , The specific meaning is as follows
$$\{\begin{array}{l}{\vec{x}}_{k+1}=B{\vec{x}}_k+\vec{f}\\ B=(D-wL{)}^{-1}((1-w)D+wU)\\ \vec{f}=(D-sL{)}^{-1}w\vec{b}\end{array}$$

import numpy as np

ERROR = 0.001
w = 0.9
A = np.array([[5, 2, 1],
     [-1, 4, 2],
     [2, -3, 10]])
b = np.array([[-12], [20], [3]])

m, n = np.shape(A)
D = np.mat(np.zeros((m, n)))
L = np.mat(np.zeros((m, n)))
U = np.mat(np.zeros((m, n)))

for i in range(m):
    for j in range(n):
        if i == j:
            D[i, j] = A[i, j]
        if i < j:
            L[i, j] = -A[i, j]
        if i > j:
            U[i, j] = -A[i, j]

# print(A)
# print(D)
# print(L)
# print(U)

x0 = np.array(np.zeros((m, 1)))
xk = np.array(np.zeros((m, 1)))

temp_mat = (D - w * L).I
B = np.dot(temp_mat, (1 - w) * D + w * U)
f = np.dot(temp_mat, b)

print("B:", B)
print("f:", f)

iter_time = 1
xk = np.dot(B, x0) + f
while(np.linalg.norm((xk - x0)) >= ERROR):
    iter_time += 1
    print(xk)
    x0 = xk
    xk = np.dot(B, xk) + f

print("The iteration time: %d" %iter_time)

In the running results, you can see that the total number of iterations 7 Time , It shows that the convergence speed of bijacobi iterative method is faster , however SOR Iteration and G-S The iterative method is almost the same , Actually G-S The iterative method is just w = 1 At the time of the SOR Iterative method . Intermediate process output is omitted , Only the last two vectors are displayed $\vec{x}$ Iterative results of

[[-4.44425225]
 [ 3.33368384]
 [ 2.22092673]]
[[-4.44445216]
 [ 3.33344291]
 [ 2.22215271]]
The iteration time: 7