Convert Msor To Sor May 2026

import numpy as np

def msor_solve(A, b, omega1, omega2, tol=1e-6, max_iter=1000):
n = len(b)
x = np.zeros_like(b)
for _ in range(max_iter):
x_old = x.copy()
# Red points (even indices, for example)
for i in range(0, n, 2):
sigma = np.dot(A[i, :], x) - A[i, i] * x[i]
x[i] = (1 - omega1) * x[i] + (omega1 / A[i, i]) * (b[i] - sigma)
# Black points (odd indices)
for i in range(1, n, 2):
sigma = np.dot(A[i, :], x) - A[i, i] * x[i]
x[i] = (1 - omega2) * x[i] + (omega2 / A[i, i]) * (b[i] - sigma)
if np.linalg.norm(x - x_old) < tol:
break
return x

To convert MSOR to SOR, we unify the relaxation factor and remove the branch.

def sor_solve(A, b, omega, tol=1e-6, max_iter=1000):
    n = len(b)
    x = np.zeros_like(b)
    for _ in range(max_iter):
        x_old = x.copy()
        for i in range(n):
            sigma = np.dot(A[i, :], x) - A[i, i] * x[i]
            x[i] = (1 - omega) * x[i] + (omega / A[i, i]) * (b[i] - sigma)
        if np.linalg.norm(x - x_old) < tol:
            break
    return x

MSOR code (two parameters):


def msor(A, b, omega_red, omega_black, max_iter):
    x = b.copy()
    for _ in range(max_iter):
        # Red nodes
        for i in red_nodes:
            x[i] = (1 - omega_red) * x[i] + omega_red / A[i,i] * (b[i] - sum(A[i,j] * x[j] for j != i))
        # Black nodes
        for i in black_nodes:
            x[i] = (1 - omega_black) * x[i] + omega_black / A[i,i] * (b[i] - sum(A[i,j] * x[j] for j != i))
    return x



Convert to SOR (single omega):


def sor(A, b, omega, max_iter):
    x = b.copy()
    for _ in range(max_iter):
        for i in range(len(b)):
            x[i] = (1 - omega) * x[i] + omega / A[i,i] * (b[i] - sum(A[i,j] * x[j] for j != i))
    return x





A = np.array([[4, -1, 0], [-1, 4, -1], [0, -1, 4]], dtype=float)
b = np.array([1, 2, 3])


Successive Over-Relaxation (SOR) is a classic iterative method for solving linear systems ( Ax = b ). The Modified Successive Over-Relaxation (MSOR) method is a variant that uses different relaxation parameters for different equations or variable groups. Converting MSOR to SOR typically involves parameter unification and algorithmic reduction, making MSOR a special case or a generalized form of SOR. convert msor to sor




MSOR is a variant where different relaxation parameters are used for different equations. This is particularly useful when the system has a block structure or when certain equations are "stiffer" than others.


In MSOR, you might have:



A common symmetric MSOR scheme (for Red-Black ordering):
[
x_i^(k+1) = (1 - \omega_1) x_i^(k) + \frac\omega_1a_ii \left( b_i - \sum_j < i a_ij x_j^(k+1) - \sum_j > i a_ij x_j^(k) \right) \quad \text(for red points)
]
[
x_i^(k+1) = (1 - \omega_2) x_i^(k) + \frac\omega_2a_ii \left( b_i - \sum_j < i a_ij x_j^(k+1) - \sum_j > i a_ij x_j^(k) \right) \quad \text(for black points)
] import numpy as np def msor_solve(A, b, omega1,


For a system ( Ax = b ) with ( A = D - L - U ) (diagonal ( D ), strictly lower ( L ), strictly upper ( U )), the SOR iteration is:


[
x_i^(k+1) = (1-\omega) x_i^(k) + \frac\omegaa_ii \left( b_i - \sum_j=1^i-1 a_ij x_j^(k+1) - \sum_j=i+1^n a_ij x_j^(k) \right)
]


where ( \omega ) is a constant relaxation parameter. To convert MSOR to SOR , we unify




For this guide, we assume:



Thus, converting MSOR to SOR means setting ( \omega_1 = \omega_2 = \omega ).
меню