Convert Msor To Sor

omega_effective = 1.5 # Based on heuristic x_sor = sor_solve(A, b, omega=omega_effective)

To convert MSOR to SOR, you have two primary strategies. The choice depends on whether your MSOR parameters are identical or different.

Before converting, you must understand what each method does.

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
 convert msor to sor

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
For a system ( Ax = b ) with ( A = D - L - U ) (diagonal ( D ), strictly lower ( L ), strictly upper ( U )), the SOR iteration is: omega_effective = 1
[
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.

Avoid these mistakes during your conversion: To convert MSOR to SOR, you have two primary strategies
| Pitfall | Why It Happens | Solution |
|--------|----------------|----------|
| Divergence after conversion | MSOR’s dual parameters may stabilize a near-singular system; SOR with a single ( \omega ) diverges. | Use a smaller ( \omega ) (e.g., 0.9) or switch to SSOR. |
| Slower convergence | MSOR exploits problem structure (e.g., anisotropy). SOR ignores that structure. | Convert to SOR with Chebyshev acceleration or use a problem-specific preconditioner. |
| Parameter mismatch | The heuristic ( \omega = (\omega_1 + \omega_2)/2 ) is too simplistic for non-symmetric matrices. | Compute the spectral radius numerically for candidate ( \omega ) values. |
| Ordering dependency | MSOR often uses red-black ordering; SOR uses natural ordering. The convergence changes. | Reorder your matrix to match SOR’s natural ordering before conversion. |
Converting an MSOR (Modified Successive Over-Relaxation) solver to a standard SOR (Successive Over-Relaxation) solver is a valuable skill for simplifying code, leveraging standard libraries, or debugging convergence issues. The conversion ranges from trivial (when MSOR parameters are equal) to mathematically nuanced (requiring spectral radius matching or heuristic averaging).
Remember that MSOR exists for a reason: it can dramatically outperform SOR on certain block-structured or anisotropic problems. Before converting, evaluate whether the loss of performance or parallelizability is worth the gain in simplicity. When the conversion is appropriate, use the mathematical formulas and code patterns provided in this guide to execute it cleanly and correctly.
If you’re looking for ready-to-use scripts to automate the conversion, check the accompanying GitHub repository (link below) for a msor_to_sor.py tool that scans your MSOR implementation and suggests an equivalent SOR parameter.

Have you successfully converted MSOR to SOR in your project? Share your experience and the omega values you used in the comments below.