|
|
| Line 1: |
Line 1: |
| In [[numerical linear algebra]], the '''Gauss–Seidel method''', also known as the '''Liebmann method''' or the '''method of successive displacement''', is an [[iterative method]] used to solve a [[linear system of equations]]. It is named after the [[Germany|German]] [[mathematician]]s [[Carl Friedrich Gauss]] and [[Philipp Ludwig von Seidel]], and is similar to the [[Jacobi method]]. Though it can be applied to any matrix with non-zero elements on the diagonals, convergence is only guaranteed if the matrix is either [[diagonally dominant matrix|diagonally dominant]], or [[Symmetric matrix|symmetric]] and [[Positive-definite matrix|positive definite]]. It was only mentioned in a private letter from Gauss to his student [[Christian Ludwig Gerling|Gerling]] in 1823.<ref>
| | They call me Emilia. Puerto Rico is where he's always been living but she needs to move because of her family. To gather cash is what her family and her appreciate. He utilized to be unemployed but now he is a computer operator but his promotion never comes.<br><br>Feel free to surf to my weblog: at home std test, [http://www.hamcass.org/index.php?document_srl=268708&mid=gido click through the up coming website], |
| {{harvnb|Gauss|1903|p=279}}; [http://gdz.sub.uni-goettingen.de/en/dms/loader/img/?PPN=PPN23601515X&DMDID=DMDLOG_0112&LOGID=LOG_0112&PHYSID=PHYS_0286 direct link].</ref> A publication was not delivered before 1874 by Seidel.
| |
| | |
| == Description ==
| |
| The Gauss–Seidel method is an [[Iterative method|iterative technique]] for solving a square system of ''n'' linear equations with unknown '''x''':
| |
| | |
| :<math>A\mathbf x = \mathbf b</math>.
| |
| | |
| It is defined by the iteration
| |
| | |
| :<math> L_* \mathbf{x}^{(k+1)} = \mathbf{b} - U \mathbf{x}^{(k)}, </math>
| |
| | |
| where the matrix ''A'' is decomposed into a [[triangular matrix|lower triangular]] component <math>L_*</math>, and a [[triangular matrix#Strictly triangular matrix|strictly upper triangular]] component ''U'': <math> A = L_* + U </math>.<ref>{{harvnb|Golub|Van Loan|1996|p=511}}.</ref> | |
| | |
| In more detail, write out ''A'', '''x''' and '''b''' in their components:
| |
| | |
| :<math>A=\begin{bmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\a_{n1} & a_{n2} & \cdots & a_{nn} \end{bmatrix}, \qquad \mathbf{x} = \begin{bmatrix} x_{1} \\ x_2 \\ \vdots \\ x_n \end{bmatrix} , \qquad \mathbf{b} = \begin{bmatrix} b_{1} \\ b_2 \\ \vdots \\ b_n \end{bmatrix}.</math>
| |
| | |
| Then the decomposition of ''A'' into its lower triangular component and its strictly upper triangular component is given by:
| |
| | |
| :<math>A=L_*+U \qquad \text{where} \qquad L_* = \begin{bmatrix} a_{11} & 0 & \cdots & 0 \\ a_{21} & a_{22} & \cdots & 0 \\ \vdots & \vdots & \ddots & \vdots \\a_{n1} & a_{n2} & \cdots & a_{nn} \end{bmatrix}, \quad U = \begin{bmatrix} 0 & a_{12} & \cdots & a_{1n} \\ 0 & 0 & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\0 & 0 & \cdots & 0 \end{bmatrix}. </math>
| |
| | |
| The system of linear equations may be rewritten as:
| |
| | |
| :<math>L_* \mathbf{x} = \mathbf{b} - U \mathbf{x} </math>
| |
| | |
| The Gauss–Seidel method now solves the left hand side of this expression for '''x''', using previous value for '''x''' on the right hand side. Analytically, this may be written as:
| |
| | |
| :<math> \mathbf{x}^{(k+1)} = L_*^{-1} (\mathbf{b} - U \mathbf{x}^{(k)}). </math>
| |
| | |
| However, by taking advantage of the triangular form of <math>L_*</math>, the elements of '''x'''<sup>(''k''+1)</sup> can be computed sequentially using [[forward substitution]]:
| |
| | |
| :<math> x^{(k+1)}_i = \frac{1}{a_{ii}} \left(b_i - \sum_{j<i}a_{ij}x^{(k+1)}_j - \sum_{j>i}a_{ij}x^{(k)}_j \right),\quad i,j=1,2,\ldots,n. </math> <ref>{{harvnb|Golub|Van Loan|1996|loc=eqn (10.1.3)}}.</ref>
| |
| | |
| The procedure is generally continued until the changes made by an iteration are below some tolerance, such as a sufficiently small [[Residual (numerical analysis)|residual]].
| |
| | |
| === Discussion ===
| |
| The element-wise formula for the Gauss–Seidel method is extremely similar to that of the [[Jacobi method]].
| |
| | |
| The computation of ''x''<sub>''i''</sub><sup>(''k''+1)</sup> uses only the elements of '''x'''<sup>(''k''+1)</sup> that have already been computed, and only the elements of '''x'''<sup>(''k'')</sup> that have not yet to be advanced to iteration ''k''+1. This means that, unlike the Jacobi method, only one storage vector is required as elements can be overwritten as they are computed, which can be advantageous for very large problems.
| |
| | |
| However, unlike the Jacobi method, the computations for each element cannot be done in [[Parallel algorithm|parallel]]. Furthermore, the values at each iteration are dependent on the order of the original equations.
| |
| | |
| Gauss-Seidel is the same as [[Successive Over-relaxation|SOR (successive over-relaxation)]] with <math>\omega=1</math>.
| |
| | |
| ==Convergence==
| |
| The convergence properties of the Gauss–Seidel method are dependent on the matrix ''A''. Namely, the procedure is known to converge if either:
| |
| * ''A'' is symmetric [[positive-definite matrix|positive-definite]],<ref>{{harvnb|Golub|Van Loan|1996|loc=Thm 10.1.2}}.</ref> or
| |
| * ''A'' is strictly or irreducibly [[diagonally dominant matrix|diagonally dominant]].
| |
| | |
| The Gauss–Seidel method sometimes converges even if these conditions are not satisfied.
| |
| | |
| == Algorithm ==
| |
| | |
| Since elements can be overwritten as they are computed in this algorithm, only one storage vector is needed, and vector indexing is omitted. The algorithm goes as follows:
| |
| | |
| Inputs: {{var|A}}, {{var|b}}
| |
| Output: <math>\phi</math>
| |
|
| |
| Choose an initial guess <math>\phi</math> to the solution
| |
| '''repeat''' until convergence
| |
| '''for''' {{var|i}} '''from''' 1 '''until''' {{var|n}} '''do'''
| |
| <math>\sigma \leftarrow 0</math>
| |
| '''for''' {{var|j}} '''from''' 1 '''until''' {{var|n}} '''do'''
| |
| '''if''' {{var|j}} ≠ {{var|i}} '''then'''
| |
| <math> \sigma \leftarrow \sigma + a_{ij} \phi_j </math>
| |
| '''end if'''
| |
| '''end''' ({{var|j}}-loop)
| |
| <math> \phi_i \leftarrow \frac 1 {a_{ii}} (b_i - \sigma)</math>
| |
| '''end''' ({{var|i}}-loop)
| |
| check if convergence is reached
| |
| '''end''' (repeat)
| |
| | |
| ==Examples==
| |
| | |
| ===An example for the matrix version===
| |
| | |
| A linear system shown as <math>A \mathbf{x} = \mathbf{b}</math> is given by:
| |
| | |
| :<math> A=
| |
| \begin{bmatrix}
| |
| 16 & 3 \\
| |
| 7 & -11 \\
| |
| \end{bmatrix}
| |
| </math> and <math> b=
| |
| \begin{bmatrix}
| |
| 11 \\
| |
| 13
| |
| \end{bmatrix}.
| |
| </math>
| |
| | |
| We want to use the equation
| |
| | |
| :<math> \mathbf{x}^{(k+1)} = L_*^{-1} (\mathbf{b} - U \mathbf{x}^{(k)}) </math>
| |
| | |
| in the form
| |
| | |
| :<math> \mathbf{x}^{(k+1)} = T \mathbf{x}^{(k)} + C </math>
| |
| | |
| where:
| |
| | |
| :<math>T = - L_*^{-1} U</math> and <math>C = L_*^{-1} \mathbf{b}.</math>
| |
| | |
| We must decompose <math>A_{}^{}</math> into the sum of a lower triangular component <math>L_*^{}</math> and a strict upper triangular component <math>U_{}^{}</math>:
| |
| | |
| :<math> L_*=
| |
| \begin{bmatrix}
| |
| 16 & 0 \\
| |
| 7 & -11 \\
| |
| \end{bmatrix}
| |
| </math> and <math> U =
| |
| \begin{bmatrix}
| |
| 0 & 3 \\
| |
| 0 & 0
| |
| \end{bmatrix}.</math>
| |
| | |
| The inverse of <math>L_*^{}</math> is:
| |
| :<math> L_*^{-1} =
| |
| \begin{bmatrix}
| |
| 16 & 0 \\
| |
| 7 & -11
| |
| \end{bmatrix}^{-1}
| |
| =
| |
| \begin{bmatrix}
| |
| 0.0625 & 0.0000 \\
| |
| 0.0398 & -0.0909 \\
| |
| \end{bmatrix}
| |
| </math>.
| |
| | |
| Now we can find:
| |
| :<math> T = -
| |
| \begin{bmatrix}
| |
| 0.0625 & 0.0000 \\
| |
| 0.0398 & -0.0909
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 0 & 3 \\
| |
| 0 & 0
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 0.000 & -0.1875 \\
| |
| 0.000 & -0.1193
| |
| \end{bmatrix}, </math>
| |
| | |
| :<math> C =
| |
| \begin{bmatrix}
| |
| 0.0625 & 0.0000 \\
| |
| 0.0398 & -0.0909
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 11 \\
| |
| 13
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 0.6875 \\
| |
| -0.7439
| |
| \end{bmatrix}. </math>
| |
| | |
| Now we have <math>T_{}^{}</math> and <math>C_{}^{}</math> and we can use them to obtain the vectors <math>\mathbf{x}</math> iteratively.
| |
| | |
| First of all, we have to choose <math>\mathbf{x}^{(0)}</math>: we can only guess. The better the guess, the quicker the algorithm will perform.
| |
| | |
| We suppose:
| |
| | |
| :<math> x^{(0)} =
| |
| \begin{bmatrix}
| |
| 1.0 \\
| |
| 1.0
| |
| \end{bmatrix}.</math>
| |
| | |
| We can then calculate:
| |
| | |
| :<math> x^{(1)} =
| |
| \begin{bmatrix}
| |
| 0.000 & -0.1875 \\
| |
| 0.000 & -0.1193
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 1.0 \\
| |
| 1.0
| |
| \end{bmatrix}
| |
| +
| |
| \begin{bmatrix}
| |
| 0.6875 \\
| |
| -0.7443
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 0.5000 \\
| |
| -0.8636
| |
| \end{bmatrix}. </math>
| |
| | |
| :<math> x^{(2)} =
| |
| \begin{bmatrix}
| |
| 0.000 & -0.1875 \\
| |
| 0.000 & -0.1193
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 0.5000 \\
| |
| -0.8636
| |
| \end{bmatrix}
| |
| +
| |
| \begin{bmatrix}
| |
| 0.6875 \\
| |
| -0.7443
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 0.8494 \\
| |
| -0.6413
| |
| \end{bmatrix}. </math>
| |
| | |
| :<math> x^{(3)} =
| |
| \begin{bmatrix}
| |
| 0.000 & -0.1875 \\
| |
| 0.000 & -0.1193
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 0.8494 \\
| |
| -0.6413 \\
| |
| \end{bmatrix}
| |
| +
| |
| \begin{bmatrix}
| |
| 0.6875 \\
| |
| -0.7443
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 0.8077 \\
| |
| -0.6678
| |
| \end{bmatrix}. </math>
| |
| | |
| :<math> x^{(4)} =
| |
| \begin{bmatrix}
| |
| 0.000 & -0.1875 \\
| |
| 0.000 & -0.1193
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 0.8077 \\
| |
| -0.6678
| |
| \end{bmatrix}
| |
| +
| |
| \begin{bmatrix}
| |
| 0.6875 \\
| |
| -0.7443
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 0.8127 \\
| |
| -0.6646
| |
| \end{bmatrix}. </math>
| |
| | |
| :<math> x^{(5)} =
| |
| \begin{bmatrix}
| |
| 0.000 & -0.1875 \\
| |
| 0.000 & -0.1193
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 0.8127 \\
| |
| -0.6646
| |
| \end{bmatrix}
| |
| +
| |
| \begin{bmatrix}
| |
| 0.6875 \\
| |
| -0.7443
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 0.8121 \\
| |
| -0.6650
| |
| \end{bmatrix}. </math>
| |
| | |
| :<math> x^{(6)} =
| |
| \begin{bmatrix}
| |
| 0.000 & -0.1875 \\
| |
| 0.000 & -0.1193
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 0.8121 \\
| |
| -0.6650
| |
| \end{bmatrix}
| |
| +
| |
| \begin{bmatrix}
| |
| 0.6875 \\
| |
| -0.7443
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 0.8122 \\
| |
| -0.6650
| |
| \end{bmatrix}. </math>
| |
| | |
| :<math> x^{(7)} =
| |
| \begin{bmatrix}
| |
| 0.000 & -0.1875 \\
| |
| 0.000 & -0.1193
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 0.8122 \\
| |
| -0.6650
| |
| \end{bmatrix}
| |
| +
| |
| \begin{bmatrix}
| |
| 0.6875 \\
| |
| -0.7443
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 0.8122 \\
| |
| -0.6650
| |
| \end{bmatrix}. </math>
| |
| | |
| As expected, the algorithm converges to the exact solution:
| |
| | |
| :<math> \mathbf{x} = A^{-1} \mathbf{b} = \begin{bmatrix} 0.8122\\ -0.6650 \end{bmatrix}. </math>
| |
| | |
| In fact, the matrix A is strictly diagonally dominant (but not positive definite).
| |
| | |
| ===Another example for the matrix version===
| |
| | |
| Another linear system shown as <math>A \mathbf{x} = \mathbf{b}</math> is given by:
| |
| | |
| :<math> A=
| |
| \begin{bmatrix}
| |
| 2 & 3 \\
| |
| 5 & 7 \\
| |
| \end{bmatrix}
| |
| </math> and <math> b=
| |
| \begin{bmatrix}
| |
| 11 \\
| |
| 13 \\
| |
| \end{bmatrix}.
| |
| </math>
| |
| | |
| We want to use the equation
| |
| | |
| :<math> \mathbf{x}^{(k+1)} = L_*^{-1} (\mathbf{b} - U \mathbf{x}^{(k)}) </math>
| |
| | |
| in the form
| |
| | |
| :<math> \mathbf{x}^{(k+1)} = T \mathbf{x}^{(k)} + C </math>
| |
| | |
| where:
| |
| | |
| :<math>T = - L_*^{-1} U</math> and <math>C = L_*^{-1} \mathbf{b}.</math>
| |
| | |
| We must decompose <math>A_{}^{}</math> into the sum of a lower triangular component <math>L_*^{}</math> and a strict upper triangular component <math>U_{}^{}</math>:
| |
| | |
| :<math> L_*=
| |
| \begin{bmatrix}
| |
| 2 & 0 \\
| |
| 5 & 7 \\
| |
| \end{bmatrix}
| |
| </math> and <math> U =
| |
| \begin{bmatrix}
| |
| 0 & 3 \\
| |
| 0 & 0 \\
| |
| \end{bmatrix}.</math>
| |
| | |
| The inverse of <math>L_*^{}</math> is:
| |
| :<math> L_*^{-1} =
| |
| \begin{bmatrix}
| |
| 2 & 0 \\
| |
| 5 & 7 \\
| |
| \end{bmatrix}^{-1}
| |
| =
| |
| \begin{bmatrix}
| |
| 0.500 & 0.000 \\
| |
| -0.357 & 0.143 \\
| |
| \end{bmatrix}
| |
| </math>.
| |
| | |
| Now we can find:
| |
| :<math> T = -
| |
| \begin{bmatrix}
| |
| 0.500 & 0.000 \\
| |
| -0.357 & 0.143 \\
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 0 & 3 \\
| |
| 0 & 0 \\
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 0.000 & -1.500 \\
| |
| 0.000 & 1.071 \\
| |
| \end{bmatrix}, </math>
| |
| | |
| :<math> C =
| |
| \begin{bmatrix}
| |
| 0.500 & 0.000 \\
| |
| -0.357 & 0.143 \\
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 11 \\
| |
| 13 \\
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 5.500 \\
| |
| -2.071 \\
| |
| \end{bmatrix}. </math>
| |
| | |
| Now we have <math>T_{}^{}</math> and <math>C_{}^{}</math> and we can use them to obtain the vectors <math>\mathbf{x}</math> iteratively.
| |
| | |
| First of all, we have to choose <math>\mathbf{x}^{(0)}</math>: we can only guess. The better the guess, the quicker will perform the algorithm.
| |
| | |
| We suppose:
| |
| | |
| :<math> x^{(0)} =
| |
| \begin{bmatrix}
| |
| 1.1 \\
| |
| 2.3 \\
| |
| \end{bmatrix}.</math>
| |
| | |
| We can then calculate:
| |
| | |
| :<math> x^{(1)} =
| |
| \begin{bmatrix}
| |
| 0 & -1.500 \\
| |
| 0 & 1.071 \\
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 1.1 \\
| |
| 2.3 \\
| |
| \end{bmatrix}
| |
| +
| |
| \begin{bmatrix}
| |
| 5.500 \\
| |
| -2.071 \\
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 2.050 \\
| |
| 0.393 \\
| |
| \end{bmatrix}. </math>
| |
| | |
| :<math> x^{(2)} =
| |
| \begin{bmatrix}
| |
| 0 & -1.500 \\
| |
| 0 & 1.071 \\
| |
| \end{bmatrix}
| |
| \times
| |
| \begin{bmatrix}
| |
| 2.050 \\
| |
| 0.393 \\
| |
| \end{bmatrix}
| |
| +
| |
| \begin{bmatrix}
| |
| 5.500 \\
| |
| -2.071 \\
| |
| \end{bmatrix}
| |
| =
| |
| \begin{bmatrix}
| |
| 4.911 \\
| |
| -1.651 \\
| |
| \end{bmatrix}. </math>
| |
| | |
| :<math> x^{(3)} = \cdots. \, </math>
| |
| | |
| If we test for convergence we'll find that the algorithm diverges. In fact, the matrix A is neither diagonally dominant nor positive definite.
| |
| Then, convergence to the exact solution
| |
| | |
| :<math> \mathbf{x} = A^{-1} \mathbf{b} = \begin{bmatrix} -38\\ 29 \end{bmatrix} </math>
| |
| | |
| is not guaranteed and, in this case, will not occur.
| |
| | |
| ===An example for the equation version===
| |
| | |
| Suppose given ''k'' equations where ''x''<sub>''n''</sub> are vectors of these equations and starting point ''x''<sub>0</sub>.
| |
| From the first equation solve for ''x''<sub>1</sub> in terms of <math>x_{n+1}, x_{n+2}, \dots, x_n.</math> For the next equations substitute the previous values of ''x''s.
| |
| | |
| To make it clear let's consider an example.
| |
| | |
| :<math>
| |
| \begin{align}
| |
| 10x_1 - x_2 + 2x_3 & = 6, \\
| |
| -x_1 + 11x_2 - x_3 + 3x_4 & = 25, \\
| |
| 2x_1- x_2+ 10x_3 - x_4 & = -11, \\
| |
| 3x_2 - x_3 + 8x_4 & = 15.
| |
| \end{align}
| |
| </math>
| |
| | |
| Solving for <math>x_1</math>, <math>x_2</math>, <math>x_3</math> and <math>x_4</math> gives:
| |
| | |
| :<math>
| |
| \begin{align}
| |
| x_1 & = x_2/10 - x_3/5 + 3/5, \\
| |
| x_2 & = x_1/11 + x_3/11 - 3x_4/11 + 25/11, \\
| |
| x_3 & = -x_1/5 + x_2/10 + x_4/10 - 11/10, \\
| |
| x_4 & = -3x_2/8 + x_3/8 + 15/8.
| |
| \end{align}
| |
| </math>
| |
| | |
| Suppose we choose (0, 0, 0, 0) as the initial approximation, then the first
| |
| approximate solution is given by
| |
| | |
| :<math>
| |
| \begin{align}
| |
| x_1 & = 3/5 = 0.6, \\
| |
| x_2 & = (3/5)/11 + 25/11 = 3/55 + 25/11 = 2.3272, \\
| |
| x_3 & = -(3/5)/5 +(2.3272)/10-11/10 = -3/25 + 0.23272-1.1 = -0.9873,\\
| |
| x_4 & = -3(2.3272)/8 +(-0.9873)/8+15/8 = 0.8789.
| |
| \end{align}
| |
| </math>
| |
| | |
| Using the approximations obtained, the iterative procedure is repeated until
| |
| the desired accuracy has been reached. The following are the approximated
| |
| solutions after four iterations.
| |
| | |
| {| class="wikitable" border="1"
| |
| |-
| |
| ! <math>x_1</math>
| |
| ! <math>x_2</math>
| |
| ! <math>x_3</math>
| |
| ! <math>x_4</math>
| |
| |-
| |
| | <math>0.6</math>
| |
| | <math>2.32727</math>
| |
| | <math>-0.987273</math>
| |
| | <math>0.878864</math>
| |
| |-
| |
| | <math>1.03018</math>
| |
| | <math>2.03694</math>
| |
| | <math>-1.01446</math>
| |
| | <math>0.984341</math>
| |
| |-
| |
| | <math>1.00659</math>
| |
| | <math>2.00356</math>
| |
| | <math>-1.00253</math>
| |
| | <math>0.998351</math>
| |
| |-
| |
| | <math>1.00086</math>
| |
| | <math>2.0003</math>
| |
| | <math>-1.00031</math>
| |
| | <math>0.99985</math>
| |
| |}
| |
| The exact solution of the system is (1, 2, −1, 1).
| |
| | |
| ===An example using Python===
| |
| The following numerical procedure simply iterates through to produce the solution vector.
| |
| | |
| <source lang="python">
| |
| #initialize the matrix
| |
| mat = [ [3/5.0, 0.0, 1/10.0, -1/5.0, 0.0 ], \
| |
| [25/11.0, 1/11.0, 0.0, 1/11.0, -3/11.0], \
| |
| [-11/10.0, -1/5.0, 1/10.0, 0, 1/10.0 ], \
| |
| [15/8.0, 0.0, -3/8.0, 1/8.0, 0.0 ] ]
| |
| | |
| x = [0,0,0,0] #initial guess
| |
| | |
| for i in xrange(6):
| |
| x[0] = mat[0][0] + mat[0][1]*0 + mat[0][2]*x[1] + mat[0][3]*x[2] + mat[0][4]*x[3]
| |
| x[1] = mat[1][0] + mat[1][1]*x[0] + mat[1][2]*0 + mat[1][3]*x[2] + mat[1][4]*x[3]
| |
| x[2] = mat[2][0] + mat[2][1]*x[0] + mat[2][2]*x[1] + mat[2][3]*0 + mat[2][4]*x[3]
| |
| x[3] = mat[3][0] + mat[3][1]*x[0] + mat[3][2]*x[1] + mat[3][3]*x[2] + mat[3][4]*0
| |
| print '%f %f %f %f' %(x[0],x[1],x[2],x[3]) #display the iterations to the user
| |
| </source>
| |
| | |
| Produces the output,
| |
| | |
| <source lang="python">
| |
| 0.600000 2.327273 -0.987273 0.878864
| |
| 1.030182 2.036938 -1.014456 0.984341
| |
| 1.006585 2.003555 -1.002527 0.998351
| |
| 1.000861 2.000298 -1.000307 0.999850
| |
| 1.000091 2.000021 -1.000031 0.999988
| |
| 1.000008 2.000001 -1.000003 0.999999
| |
| </source>
| |
| | |
| ===Program to solve arbitrary no. of equations using Matlab===
| |
| <source lang="matlab">
| |
| disp('Give the input to solve the set of equations AX=B')
| |
| a=input('Input the square matrix A : \n');
| |
| b=input('Input the column matrix B : \n');
| |
| m=length(a);
| |
| %z is a two dimensional array in which row corresponds to values of X in a
| |
| %specific iteration and the column corresponds to values of specific
| |
| %element of X in different iterations
| |
| c=0;%random assignment
| |
| e=1;%'e' represents the maximum error
| |
| d=0;%random assignment
| |
| for u=1:m
| |
| x(u)=b(u,1)/a(u,u);
| |
| z(1,u)=0;%initializing the values for matrix X(x1;x2;...xm)
| |
| end
| |
| l=2;%'l' represents the iteration no.
| |
| %loop for finding the convergence factor (C.F)
| |
| for r = 1:m
| |
| for s = 1:m
| |
| if r~=s
| |
| p(r)=abs(a(r,s)/a(r,r))+d;%p(r) is the C.F for equation no. r
| |
| d=p(r);
| |
| end
| |
| end
| |
| d=0;
| |
| end
| |
| if min(p)>=1 %at least one equation must satisfy the condition p<1
| |
| fprintf('Roots will not converge for this set of equations')
| |
| else
| |
| while(e>=1e-4)
| |
| j1=1;%while calculating elements in first column we consider only the old values of X
| |
| for i1=2:m
| |
| q(j1)=(a(j1,i1)/a(j1,j1))*z(l-1,i1)+c;
| |
| c=q(j1);
| |
| end
| |
| c=0;
| |
| z(l,j1)=x(j1)-q(j1);%elements of z in the iteration no. l
| |
| x(j1)=z(l,j1);
| |
| for u=1:m
| |
| x(u)=b(u,1)/a(u,u);
| |
| z(1,u)=0;
| |
| end
| |
| for j1=2:m-1%for intermediate columns between 1 and m, we use the updated values of X
| |
| for i1=1:j1-1
| |
| q(j1)=(a(j1,i1)/a(j1,j1))*z(l,i1)+c;
| |
| c=q(j1);
| |
| end
| |
| for i1=j1+1:m
| |
| q(j1)=(a(j1,i1)/a(j1,j1))*z(l-1,i1)+c;
| |
| c=q(j1);
| |
| end
| |
| c=0;
| |
| z(l,j1)=x(j1)-q(j1);
| |
| x(j1)=z(l,j1);
| |
| for u=1:m
| |
| x(u)=b(u,1)/a(u,u);
| |
| z(1,u)=0;
| |
| end
| |
| end
| |
| j1=m;%for the last column, we use only the updated values of X
| |
| for i1=1:m-1
| |
| q(j1)=(a(j1,i1)/a(j1,j1))*z(l,i1)+c;
| |
| c=q(j1);
| |
| end
| |
| c=0;
| |
| z(l,j1)=x(j1)-q(j1);
| |
| for v=1:m
| |
| t=abs(z(l,v)-z(l-1,v));%calculates the error
| |
| end
| |
| e=max(t);%evaluates the maximum error out of errors of all elements of X
| |
| l=l+1;%iteration no. gets updated
| |
| for i=1:m
| |
| X(1,i)=z(l-1,i);%the final solution X
| |
| end
| |
| end
| |
| %loop to show iteration number along with the values of z
| |
| for i=1:l-1
| |
| for j=1:m
| |
| w(i,j+1)=z(i,j);
| |
| end
| |
| w(i,1)=i;
| |
| end
| |
| disp(' It. no. x1 x2 x3 x4 ')
| |
| disp(w)
| |
| disp('The final solution is ')
| |
| disp(X)
| |
| fprintf('The total number of iterations is %d',l-1)
| |
| end
| |
| </source>
| |
| | |
| Program output is
| |
| <source lang="matlab">
| |
| Give the input to solve the set of equations AX=B
| |
| Input the square matrix A :
| |
| [10 -2 -1 -1;-2 10 -1 -1;-1 -1 10 -2;-1 -1 -2 10]
| |
| Input the column matrix B :
| |
| [3;15;27;-9]
| |
| It. no. x1 x2 x3 x4
| |
| | |
| 1.0000 0 0 0 0
| |
| 2.0000 0.3000 1.5600 2.8860 -0.1368
| |
| 3.0000 0.8869 1.9523 2.9566 -0.0248
| |
| 4.0000 0.9836 1.9899 2.9924 -0.0042
| |
| 5.0000 0.9968 1.9982 2.9987 -0.0008
| |
| 6.0000 0.9994 1.9997 2.9998 -0.0001
| |
| 7.0000 0.9999 1.9999 3.0000 -0.0000
| |
| 8.0000 1.0000 2.0000 3.0000 -0.0000
| |
| | |
| The final solution is
| |
| | |
| 1.0000 2.0000 3.0000 -0.0000
| |
| | |
| The total number of iterations is 8
| |
| </source>
| |
| | |
| ==See also==
| |
| *[[Jacobi method]]
| |
| *[[Successive over-relaxation]]
| |
| *[[Iterative_method#Linear_systems|Iterative method. Linear systems]]
| |
| *[[Belief_propagation#Gaussian_belief_propagation_.28GaBP.29|Gaussian belief propagation]]
| |
| *[[Matrix splitting]]
| |
| | |
| ==Notes==
| |
| {{reflist}}
| |
| | |
| ==References==
| |
| * {{citation | first = Carl Friedrich | last = Gauss | authorlink = Carl Friedrich Gauss | title = Werke | publisher = Köninglichen Gesellschaft der Wissenschaften | location = Göttingen | date = 1903 | volume = 9 | language = German}}.
| |
| * {{citation | first1=Gene H. | last1=Golub | author1-link=Gene H. Golub | first2=Charles F. | last2=Van Loan | author2-link=Charles F. Van Loan | year=1996 | title=Matrix Computations | edition=3rd | publisher=Johns Hopkins | place=Baltimore | isbn=978-0-8018-5414-9}}.
| |
| *{{MathWorld|urlname=Gauss-SeidelMethod|title=Gauss-Seidel Method|author=Black, Noel and Moore, Shirley}}
| |
| {{CFDWiki|name=Gauss-Seidel_method}}
| |
| | |
| ==External links==
| |
| *{{springer|title=Seidel method|id=p/s083810}}
| |
| *[http://www.math-linux.com/spip.php?article48 Gauss–Seidel from www.math-linux.com]
| |
| *[http://math.fullerton.edu/mathews/n2003/GaussSeidelMod.html Module for Gauss–Seidel Iteration]
| |
| *[http://numericalmethods.eng.usf.edu/topics/gauss_seidel.html Gauss–Seidel] From Holistic Numerical Methods Institute
| |
| *[http://www.webcitation.org/query?url=http://www.geocities.com/rsrirang2001/Mathematics/NumericalMethods/gsiedel/gsiedel.htm&date=2009-10-26+01:52:27 Gauss Siedel Iteration from www.geocities.com]
| |
| *[http://www.netlib.org/linalg/html_templates/node14.html#figgs The Gauss-Seidel Method]
| |
| *[http://arxiv.org/abs/0901.4192 Bickson]
| |
| *[http://matlabdb.mathematik.uni-stuttgart.de/gauss_seidel.m?MP_ID=406 Matlab code]
| |
| *[http://adrianboeing.blogspot.com/2010/02/solving-linear-systems.html C code example]
| |
| {{Numerical linear algebra}}
| |
| | |
| {{DEFAULTSORT:Gauss-Seidel Method}}
| |
| [[Category:Numerical linear algebra]]
| |
| [[Category:Articles with example pseudocode]]
| |
| [[Category:Relaxation (iterative methods)]]
| |