Esiste una semplice regola empirica per dire se vale la pena fare SOR invece di Gauss-Seidel? (e modo possibile come stimare il parametro di realxation )$\omega$

Intendo solo guardando la matrice o la conoscenza di un problema particolare che la matrice rappresenta?

Stavo leggendo la risposta a queste domande: ci sono euristiche per l'ottimizzazione del successivo metodo di rilassamento eccessivo (SOR)? ma è un po 'troppo sofisticato. Non vedo l'euristica semplice su come stimare il raggio spettrale solo osservando la matrice (o il problema che rappresenta).

Vorrei qualcosa di molto più semplice: solo alcuni esempi di matrici (problemi) per le quali SOR convergono più velocemente.

---

Stavo sperimentando SOR per la matrice di questo re: dove$A = I + C + R$$I$ è matrice di identità, $C_{ij}=c$ $\forall i,j$ e $R_{ij}$ sono numeri casuali dalla distribuzione unifrom tale che $|R_{ij}|<r$ . Stavo pensando che ci sarebbe stata una certa dipendenza di ottimale $\omega$dai parametri $c,r$ .

EDIT: ho usato molto piccoli $c,r$per assicurarmi che $A$ sia fortemente dominante in diagonale. ( $|c|<0.1$ , $r<2|c|$ per matrice di dimensione 5-10). Dovrei anche dire che questi $A$ erano reali e simmetrici.

Tuttavia, ho scoperto che Gauss-Seidel ( $\omega=1$ ) è quasi sempre il migliore (?) . Questo significa che ci deve essere una maggiore correlazione tra $A_{ij}$ per trarre vantaggio da SOR? O ho fatto qualcosa di sbagliato?

---

So che SOR non è il risolutore più efficiente (rispetto a CG, GMRES ...) ma è semplice da implementare e paraelizzare e modificare per un problema particolare. Sicuro per la prototipazione.

La convergenza dei solutori iterativi classici per sistemi lineari è determinata dal raggio spettrale della matrice di iterazione, . Per un sistema lineare generale, è difficile determinare un parametro SOR ottimale (o addirittura buono) a causa della difficoltà nel determinare il raggio spettrale della matrice di iterazione. Di seguito ho incluso molti dettagli aggiuntivi, incluso un esempio di un problema reale in cui è noto il peso SOR ottimale.$\rho(\mathbf{G})$

Raggio spettrale e convergenza

Il raggio spettrale è definito come il valore assoluto dell'autovalore di massima magnitudine. Un metodo converge se e un raggio spettrale più piccolo significa una convergenza più rapida. SOR agisce modificando la suddivisione della matrice utilizzata per derivare la matrice di iterazione in base alla scelta di un parametro di ponderazione ω , eventualmente diminuendo il raggio spettrale della matrice di iterazione risultante.$\rho<1$$\omega$

Frazionamento a matrice

Per la discussione che segue, presumo che il sistema da risolvere sia dato da

$$\mathbf{A}x=b,$$

con un'iterazione del modulo

$$x^{(k+1)}=v+\mathbf{G}x^{(k)},$$

dove è un vettore e il numero di iterazione k è indicato con x ( k ) .$v$$k$$x^{(k)}$

SOR prende una media ponderata della vecchia iterazione e di una iterazione di Gauss-Seidel. Il metodo Gauss-Seidel si basa su una suddivisione matriciale del modulo

$$\mathbf{A} = \mathbf{D} + \mathbf{L} + \mathbf{U}$$

dove è la diagonale di A , L è una matrice triangolare inferiore contenente tutti gli elementi di A strettamente sotto la diagonale e R è una matrice triangolare superiore contenente tutti gli elementi di A rigorosamente sopra la diagonale. L'iterazione di Gauss-Seidel viene quindi data da$\mathbf{D}$$\mathbf{A}$$\mathbf{L}$$\mathbf{A}$$\mathbf{R}$$\mathbf{A}$

$$x^{(k+1)}=(\mathbf{D}+\mathbf{L})^{-1}b+\mathbf{G}_{\rm G-S}x^{(k)}$$

e la matrice di iterazione è

$$\mathbf{G}_{\rm G-S}=-(\mathbf{D}+\mathbf{L})^{-1}\mathbf{U}.$$

SOR può quindi essere scritto come

$$x^{(k+1)}=\omega(\mathbf{D}+\omega\mathbf{L})^{-1}b+\mathbf{G}_{\rm SOR}x^{(k)}$$

dove

$$\mathbf{G}_{\rm SOR} = (\mathbf{D}+\omega\mathbf{L})^{-1}((1-\omega)\mathbf{D}-\omega\mathbf{U}).$$

$\omega$

SOR ottimale

Un esempio realistico in cui è noto il coefficiente di ponderazione ottimale si pone nel contesto della risoluzione di un'equazione di Poisson:

$$\nabla^2 u = f~{\rm in}~\Omega\\ u = g~{\rm on}~\partial\Omega$$

Discretizzare questo sistema su un dominio quadrato in 2D usando differenze finite del secondo ordine con spaziatura della griglia uniforme si traduce in una matrice a bande simmetriche con 4 sulla diagonale, -1 immediatamente sopra e sotto la diagonale e altre due bande di -1 a una certa distanza dalla diagonale. Ci sono alcune differenze dovute alle condizioni al contorno, ma questa è la struttura di base. Data questa matrice, la scelta decisamente ottimale per il coefficiente SOR è data da

$$\omega = \dfrac{2}{1+\sin(\pi \Delta x/L)}$$

$\Delta x$$L$

Come puoi vedere, SOR raggiunge la precisione della macchina in circa 100 iterazioni a quel punto Gauss-Seidel è circa 25 ordini di grandezza peggiori. Se vuoi giocare con questo esempio, ho incluso il codice MATLAB che ho usato di seguito.

clear all
close all

%number of iterations:
niter = 150;

%number of grid points in each direction
N = 16;
% [x y] = ndgrid(linspace(0,1,N),linspace(0,1,N));
[x y] = ndgrid(linspace(-pi,pi,N),linspace(-pi,pi,N));
dx = x(2,1)-x(1,1);
L = x(N,1)-x(1,1);

%desired solution:
U = sin(x/2).*cos(y);

% Right hand side for the Poisson equation (computed from U to produce the
% desired known solution)
Ix = 2:N-1;
Iy = 2:N-1;
f = zeros(size(U));
f(Ix,Iy) = (-4*U(Ix,Iy)+U(Ix-1,Iy)+U(Ix+1,Iy)+U(Ix,Iy-1)+U(Ix,Iy+1));

figure(1)
clf
contourf(x,y,U,50,'linestyle','none')
title('True solution')

%initial guess (must match boundary conditions)
U0 = U;
U0(Ix,Iy) = rand(N-2);

%Gauss-Seidel iteration:
UGS = U0; EGS = zeros(1,niter);
for iter=1:niter
    for iy=2:N-1
        for ix=2:N-1
            UGS(ix,iy) = -1/4*(f(ix,iy)-UGS(ix-1,iy)-UGS(ix+1,iy)-UGS(ix,iy-1)-UGS(ix,iy+1));
        end
    end

    %error:
    EGS(iter) = sum(sum((U-UGS).^2))/sum(sum(U.^2));
end

figure(2)
clf
contourf(x,y,UGS,50,'linestyle','none')
title(sprintf('Gauss-Seidel approximate solution, iteration %d', iter))
drawnow

%SOR iteration:
USOR = U0; ESOR = zeros(1,niter);
w = 2/(1+sin(pi*dx/L));
for iter=1:niter
    for iy=2:N-1
        for ix=2:N-1
            USOR(ix,iy) = (1-w)*USOR(ix,iy)-w/4*(f(ix,iy)-USOR(ix-1,iy)-USOR(ix+1,iy)-USOR(ix,iy-1)-USOR(ix,iy+1));
        end
    end

    %error:
    ESOR(iter) = sum(sum((U-USOR).^2))/sum(sum(U.^2));
end

figure(4)
clf
contourf(x,y,USOR,50,'linestyle','none')
title(sprintf('Gauss-Seidel approximate solution, iteration %d', iter))
drawnow


figure(5)
clf
semilogy(EGS,'b')
hold on
semilogy(ESOR,'r')
title('L2 relative error')
xlabel('Iteration number')
legend('Gauss-Seidel','SOR','location','southwest')

Questo lato delle cose non è davvero la mia specialità, ma non penso che questo sia un test super-giusto per molte applicazioni realistiche.

Non sono sicuro di quali valori si stava utilizzando per c e r , ma ho il sospetto si stava lavorando con matrici estremamente mal condizionata. (Di seguito è riportato un codice Python che mostra che queste potrebbero non essere le matrici più invertibili.)

>>> import numpy
>>> for n in [100, 1000]:
...     for c in [.1, 1, 10]:
...         for r in [.1, 1, 10]:
...             print numpy.linalg.cond(
...                 numpy.eye(n) + 
...                 c * numpy.ones((n, n)) + 
...                 r * numpy.random.random((n, n))
...             )
... 
25.491634739
2034.47889101
2016.33059429
168.220149133
27340.0090644
5532.81258852
1617.33518781
42490.4410689
5326.3865534
6212.01580004
91910.8386417
50543.9269739
24737.6648458
271579.469212
208913.592289
275153.967337
17021788.5576
117365.924601

Se in realtà avessi bisogno di invertire questa matrice mal condizionata, a) utilizzeresti un metodo specializzato eb) probabilmente dovresti semplicemente trovare un nuovo campo 😉

Per matrici ben condizionate di qualsiasi dimensione, è probabile che SOR sia più veloce. Per problemi reali in cui la velocità conta, sarebbe raro usare SOR - dal lato sofisticato, c'è molto di meglio in questi giorni; dal lato lento ma affidabile, SOR non è il massimo che puoi fare.

OK, quindi per le matrici simmetriche di questo re:

1 t 0 0 0 0 t t 0 0 
t 1 0 0 0 0 0 0 0 0 
0 0 1 0 0 0 0 t 0 t 
0 0 0 1 0 0 0 0 0 t 
0 0 0 0 1 t 0 0 0 0 
0 0 0 0 t 1 0 t 0 0 
t 0 0 0 0 0 1 0 0 0 
t 0 t 0 0 t 0 1 0 0 
0 0 0 0 0 0 0 0 1 t 
0 0 t t 0 0 0 0 t 1 

$t$$t$$t$

$t_i = c + random(-r,r)$

$t$$c=0,r=0.1$$t$

(Questa è solo osservazione empirica, niente di rigoroso)