EXERCÍCIO PROGRAMA 1

PEDRO T. P. LOPES

1. Descrição do problema
1.1. O método SOR. Seja A ∈ Mn×n (R) uma matriz n × n e y ∈ Rn . Para resolver a equação linear
Ax = y, vimos que, sob certas condições, podemos usar o método de Gauss-Seidel. Para tanto:
• Escolhemos uma aproximação inicial da solução x(0) ∈ Rn .
(n+1) (n)
(n+1) yj Pj−1 aji xi Pn aji xi
• Calculamos as iteradas através da expressão: xj = ajj − i=1 ajj − i=j+1 ajj .
Em certas situações, podemos considerar a seguinte variação desse método. Fixamos um determinado
ω ∈]0, 2[ e procedemos da seguinte maneira:
• Escolhemos uma aproximação inicial da solução x(0) ∈ Rn .
• Calculamos as iteradas através da expressão:
 
j−1 n
(n+1) (n) ω  X (n+1)
X (n)
xj = (1 − ω)xj + yj − aji xi − aji xi  .
ajj i=1 i=j+1

Observe que quando ω = 1 reobtemos o método de Gauss-Seidel.

O método acima também é conhecido como método SOR (vem do inglês de Successive Over-
Relaxation). O objetivo é implementar o método SOR para resolver uma equação linear que aparece
na resolução de um problema de contorno.

1.2. Aplicação: Método das diferenças finitas. Consideremos o seguinte problema:

u00 (x) = f (x), x ∈ [0, 1]
(1.1)
u(0) = u(1) = 0.

Gostaríamos de resolvê-lo pelo método das diferenças finitas. A ideia é obter a aproximação da
solução em finitos pontos, usando a seguinte aproximação1:
u(x + h) + u(x − h) − 2u(x)
u00 (x) ≈ ,
h2
em que h > 0.
Assim, fixando N ∈ N, definimos h = N1+1 , {x1 , ..., xN } ⊂ [0, 1] por xj = jh = N j+1 e {f1 , ..., fN }
por fj = f (xj ), j ∈ {1, ..., N }. Somos, assim, levados a seguinte equação para achar {U1 , ..., UN }, em

1A ideia é usar as aproximações:

1 00
u(x + h) = u(x) + u0 (x)h + u (x)h2 + o(h2 )
2
1
u(x − h) = u(x) − u0 (x)h + u00 (x)h2 + o(h2 )
2
Somando as duas, obtemos a aproximação adequada. O resto de Taylor é indicado por o(h2 ). Para quem tiver
curiosidade, veja o Apostol para entender o significado de o(h2 ).
1
 EXERCÍCIO PROGRAMA 1 2

que Uj ≈ u(xj ) :  
2 −1 0 ··· 0
−h2 f1
   
 −1 2 −1 ··· 0 U1

 ..   U2 
..
  −h2 f2 
 0 −1 2 . .
 . 
 .    =

.. .

. .

 . .. ..  
 ..

. . −1  UN −h2 fN
0 ··· 0 −1 2
Vamos agora aplicar o método SOR os sistema linear acima. Assim, obtemos
(n+1) (n) ω 2 (n)

U1 = (1 − ω)U1 + −h f1 + U2 ,
2
(n+1) (n) ω (n+1) (n)

Uj = (1 − ω)Uj + −h2 fj + Uj−1 + Uj+1 , j ∈ {2, ..., N − 1},
2
(n+1) (n) ω 2 (n+1)

UN = (1 − ω)UN + −h fN + UN −1 .
2
Observe que as iterações podem ser feitas usando um único vetor U de N elementos.
1.3. Problema: Observe que dado f (x) = sen(πx), a solução da Equação (1.1) é u(x) = − sen(πx) π2 .
No problema, sempre consideraremos f e u dados por estas expressões.
Faça um programa que receba um valor N ∈ N de entrada. A partir daí, o programa calcula
 −1    
ω = 2 1 + sen( Nπ+1 ) , f = (f1 , ..., fN ) por fj = f N j+1 e u = (u1 , ..., uN ) por uj = u N j+1 .
Considerando U (0) = (0, 0, ..., 0), o programa deve dizer quantas iterações são necessárias para que
kU (n) − uk seja menor do que 0.01 e imprimir U (n) quando isto ocorre. Ou seja, o programa deve fazer
as iterações do método SOR até que kU (n) − uk seja menor do que 0.01.
Lembramos que kyk = maxj∈{1,...,N } |yj |.
Algumas dicas que podem facilitar:
(1) Comece o programa com import numpy as np
(2) O vetor (x1 , ..., xN ) pode ser calculado facilmente como x = np.linspace(h, 1 − h, N ). Este
vetor tem N pontos que vão de h = N1+1 até 1 − h = NN+1 .
(3) Os vetores f e u podem ser facilmente calculados por u = −np.sin(np.pi*x)/(np.pi**2) e
f = np.sin(np.pi*x).
(4) Fixe um vetor U com n elementos para servir como U (n) . Ele pode ser inicializado como
U = np.zeros(N), já que U (0) = (0, 0, ..., 0).
(5) Por fim, kU − uk pode ser calculado como np.max(np.abs(U-u)).
(6) Cuidado! Os vetores em Python começam indexados por 0.
Com todas essas dicas, o que faltará será implementar o método SOR, parando quando kU − uk < 0.01
e contando o número de iterações que foi necessário para chegar nessa precisão. A implementação pode
ser feita com poucas linhas!
1.4. O que deve ser entregue: Deve ser entregue o programa utilizado para fazer as contas e os
resultados obtidos para N = 4, 9 e 14, isto é, os vetores U (n) finais obtidos e os números de iterações que
foram necessários para chegar nesses vetores. Os resultados devem ser comparados com o método de
Gauss-Seidel (para obter os resultados com o método de Gauss-Seidel é só colocar ω = 1 no programa.
O programa com esta modificação não precisa ser entregue. Somente os resultados).
Os resultados podem ser escritos como comentários no mesmo arquivo .py.
Atenção! O método SOR deve ser implementado por vocês (não pode pegar comandos prontos, caso
estes existam, do Python).