2-Sistemas de Ecuaciones Lineales

Universidad de Montevideo
Facultad de Ingeniera
Curso Terico de
CLCULO NUMRICO
Tema: SISTEMAS LINEALES
Objetivos de aprendizaje
Conocer la mecnica del mtodo de Gauss y cmo y porqu se hace pivotaje.
Comprender cmo el mtodo de Gauss puede interpretarse como una descomposicin
triangular.
Conocer varios mtodos de descomposicin triangular, cundo son aplicables y qu
ventajas tienen.
Comprender el concepto de sistema mal condicionado y su relacin con el nmero de
condicin.
Conocer los efectos del mal condicionamiento en la sensibilidad de la solucin a errores en
los datos y en la relacin entre residuo y error.
Germn BRESCIANO
2 SISTEMAS DE ECUACIONES LINEALES............................................................................... 2-1
2.1 INTRODUCCIN...........................................................................................................................2-1
2.2 GENERALIDADES........................................................................................................................2-2
2.3 MTODOS DIRECTOS...................................................................................................................2-3
2.3.1 Sistemas con matriz triangular superior .......................................................................... 2-3
2.3.2 Mtodo de Gauss .............................................................................................................. 2-3
2.3.2.2 Pivoteo .........................................................................................................................................2-5
2.3.3 Mtodos de descomposicin triangular............................................................................ 2-6
2.3.3.2 Mtodo de Crout...........................................................................................................................2-8
2.3.3.3 Mtodo de Doolitle.......................................................................................................................2-9
2.3.3.4 Mtodo de Cholesky.....................................................................................................................2-9
2.3.3.5 Aplicacin a matrices tridiagonales............................................................................................ 2-10
2.3.4 Anlisis de error ............................................................................................................. 2-11
2.3.4.1 Sistemas mal condicionados....................................................................................................... 2-11
2.3.4.2 Normas de vectores y matrices................................................................................................... 2-12
2.3.4.3 Anlisis de perturbaciones.......................................................................................................... 2-13
2.3.4.4 Errores de redondeo ................................................................................................................... 2-13
2.3.5 Mejora de la solucin y estimacin del nmero de condicin........................................ 2-14
2.3.6 Clculo de determinantes ............................................................................................... 2-15
2.4 MTODOS ITERATIVOS .............................................................................................................2-15
2.4.1 Mtodo de Jacobi ........................................................................................................... 2-15
2.4.2 Mtodo de Gauss Seidel ................................................................................................. 2-17
2.4.3 Convergencia.................................................................................................................. 2-17
Sistemas de ecuaciones lineales 2-1
2 Sistemas de ecuaciones lineales
2.1 Introduccin
La necesidad de resolver sistemas de ecuaciones lineales se presenta en los ms diversos
campos de ingeniera, desde transmisin de calor hasta circuitos de corriente alterna.
En lo que sigue veremos cmo resolver sistemas de ecuaciones lineales de n ecuaciones con n
incgnitas, con coeficientes reales, aunque casi todo lo que veremos se aplica tambin a
sistemas con coeficientes complejos.
Estos sistemas suelen representarse en la forma Ax = b donde A es una matriz real de nxn y b
es un vector de R
n
.
Supondremos que A es no singular, en cuyo caso el sistema es compatible y determinado, es
decir, tiene solucin y es nica.
Si bien tericamente este sistema puede resolverse calculando x = A
-1
b , para ello es necesario
calcular la matriz inversa de A, lo cual implica mucho ms esfuerzo de clculo
1
que resolver el
sistema por otros mtodos.
Algo similar ocurre con el mtodo de Cramer, que implica gran esfuerzo para calcular los
determinantes involucrados, lo que lo hace muy poco prctico.
Ejemplo
Se tiene una placa de 2cm por 2cm de 1cm de espesor cuyas superficies superior e inferior
estn trmicamente aisladas.
Dos bordes opuestos se mantienen a 50C y los otros dos a 0C y 100C respectivamente.
Se quiere calcular el perfil de temperatura en el interior de la placa, para lo cual se considera
una retcula de puntos separados 0.5cm como se muestra en la Figura 2-1.
Figura 2-1 Perfil de temperatura en una placa

1
del orden se n
2
(n!) operaciones aritmticas
100C
100C
50C
50C 50C
50C
50C
50C
0C
0C
0C
u
1
u
2
u
3
u
4
u
5
u
6
u
7
u
8
u
9
100C
Su u(x,y) representa la temperatura en cada punto, se verifica que 0
2
2
2
2
=
y
u
x
u
Aproximando las derivadas por diferencias finitas, se llega al siguiente sistema lineal:
= +
= +
= +
= +
= +
= +
= +
= +
=
150 4
50 4
50 4
100 4
0 4
0 4
150 4
50 4
50 4
9 8 6
9 8 7 5
8 7 4
9 6 5 3
8 6 5 4 2
7 5 4 1
6 3 2
5 3 2 1
4 2 1
u u u
u u u u
u u u
u u u u
u u u u u
u u u u
u u u
u u u u
u u u
2.2 Generalidades
Por lo general se aplica alguno de los mtodos de resolucin que veremos sin evaluar
previamente el determinante; en muchas ocasiones el determinante y la inversa de la matriz
son un subproducto de los clculos efectuados.
Los algoritmos se evalan en funcin de su eficacia, teniendo en cuenta tres caractersticas
fundamentales:
1. Nmero de operaciones necesarias. Se tienen en cuenta las operaciones elementales
entre nmeros en punto flotante (flops): +, -, / *, que es un buen indicador del tiempo de
CPU.
2. Necesidades de memoria, los diferentes mtodos requieren almacenar las matrices de
distinta forma en la computadora y esto cambia las necesidades de memoria.
3. Rango de aplicabilidad: no todos los mtodos sirven para cualquier matriz no singular;
adems, en funcin del mtodo y de las propiedades de la matriz, la precisin de los
resultados puede verse afectada dramticamente.
Los tres criterios deben ser tenidos igualmente en cuenta ya que, por ejemplo, de nada sirve un
mtodo rpido y preciso si no alcanza la memoria disponible.
Las matrices ms comunes en ingeniera pueden clasificarse en dos categoras:
1. Matrices llenas pero no muy grandes. Que poseen pocos elementos nulos y que el nmero
de ecuaciones es de unos cientos. Estas matrices aparecen en problemas estadsticos,
fsicos y de ingeniera.
2. Matrices vacas y muy grandes. En oposicin al caso anterior, tienen pocos elementos no
nulos y adems estn situados con una cierta regularidad. En la mayora de estos casos el
nmero de ecuaciones supera los miles. Estas matrices son comunes en la resolucin de
ecuaciones diferenciales de problemas de ingeniera.
En general los mtodos directos se emplean con las primeras, mientras que los mtodos
iterativos se aplican a las segundas.
En todo lo que veremos se supone que los elementos de A y b son reales, pero casi todo es
vlido si fueran complejos. Adems en ese caso se puede replantear el problema como el
siguiente sistema de coeficientes reales de 2n ecuaciones:
(
=
(

d
c
z
y
C D
D C
donde C y D son matrices reales de nxn, y c, d, y y z son vectores de R
n
tales que:
D C A i + =
d c b i + =
z y x i + =
2.3 Mtodos directos
Los mtodos directos de resolucin de sistemas de ecuaciones lineales son aquellos que
permiten obtener la solucin con un nmero finito de operaciones, que depende del tamao de
la matriz.
Adems, si se pudiera emplear una aritmtica exacta, con los mtodos directos se obtendra la
solucin exacta del sistema.
2.3.1 Sistemas con matriz triangular superior
Si la matriz A es triangular superior, es decir
(
(
(
(
(
(
= =

nn
n n n n
n n
n n
u
u u
u u u
u u u u
0 0 0
0 0
0
, 1 1 , 1
2 1 , 2 22
1 1 , 1 12 11
L
L
M M O M M
L
L
U A
la solucin de la ltima ecuacin es trivial, x
n
= b
n
/u
nn
.
Una vez conocido x
n
, la penltima ecuacin se resuelve fcilmente despejando x
n-1
.
Conocidos ahora x
n
y x
n-1
, se pasa a la ecuacin anterior y as sucesivamente.
Se obtiene el algoritmo de sustitucin hacia atrs:
2-1
nn n n
u b x / =
2-2 1 2 1 /
1
, , , n- n- i u x u b x
ii
n
i j
j ij i i
=
|
|
\
|
=

+ =
Por supuesto la solucin existe pues siendo U no singular, todos los trminos de su diagonal
son no nulos.
El determinante puede calcularse multiplicando los trminos de la diagonal.
El nmero de operaciones es n
2
.
2.3.2 Mtodo de Gauss
En el mtodo de eliminacin de Gauss el problema original, Ax = b, se transforma, mediante
adecuadas combinaciones lineales de las ecuaciones, en un sistema de la forma Ux = y donde
U es una matriz triangular superior. Este nuevo sistema equivalente al original se resuelve
usando el algoritmo de sustitucin hacia atrs ya visto (2-1 y 2-2).
Durante la transformacin del sistema original al equivalente con matriz triangular, las
operaciones (que slo dependen de la matriz A) se realizan sobre la matriz y al mismo tiempo
sobre el trmino independiente.
El algoritmo de este mtodo puede escribirse:
2-3
) 1 (
) 1 (
=
k
kk
k
ik
ik
a
a
l
2-4
) 1 ( ) 1 ( ) (
=
k
kj ik
k
ij
k
ij
a l a a
+ =
+ =
=
,...,n k j
,...,n k i
,...,n k
1
1
1 1
2-5
) 1 ( ) 1 ( ) (
=
k
k ik
k
i
k
i
b l b b
donde los trminos de superndice (0) son iguales a los originales del sistema de ecuaciones.
Obsrvese que los elementos subdiagonales de A
(n-1)
sern nulos.
A cada uno de los trminos que aparecen en la diagonal de la matriz anterior se le denomina
pivote
2
, los cuales deben ser no nulos para que 2-3 pueda evaluarse.
El nmero de operaciones necesarias en esta fase de eliminacin es de (4n
3
+3n
2
-7n)/6.
Si se tienen en cuenta las n
2
operaciones correspondientes a la fase de sustitucin hacia atrs,
el nmero total de operaciones elementales para el mtodo de Gauss es (4n
3
+9n
2
-7n)/6
Ejemplo
Consideremos en sistema
(
(
(
=
(
(
(
(
(
(
13
8
15
3 1 1
4 1 3
1 2 4
3
2
1
x
x
x
Como vamos a modificar simultneamente la matriz y el trmino independiente, usaremos la
matriz ampliada
(
(
(
13 3 1 1
8 4 1 3
15 1 2 4
para eliminar los elementos subdiagonales de la primera columna, a segunda fila le sumamos
la primera por y a la tercera fila le sumamos la primera por obteniendo
(
(
(
25 . 9 75 . 2 5 . 0 0
25 . 19 75 . 4 5 . 2 0
15 1 2 4
para eliminar el elemento subdiagonal de la segunda columna, a la tercera fila le sumamos la
segunda por (0.5/2.5) obteniendo
(
(
(
40 . 5 80 . 1 0 0
25 . 19 75 . 4 5 . 2 0
15 1 2 4
que se resuelve por sustitucin hacia atrs dando x
1
=2, x
2
=-2 y x
3
=3

2
Ntese que los pivotes no coinciden con los trminos originales de la diagonal de A; es decir,
0 ) 1 (
kk
k
kk
a a

2.3.2.2 Pivoteo
Se ha supuesto que los pivotes sean distintos de cero. Si durante el proceso de eliminacin se
obtiene un pivote nulo, por ejemplo el
) 1 ( k
kk
a , se debe buscar en la parte inferior de la columna
k-sima un coeficiente no nulo, es decir de entre los
) 1 ( k
ik
a i=k+1,,n se toma uno que sea
distinto de cero. Se intercambia entonces la fila k (y su trmino independiente) con la fila i (y su
trmino independiente) que se haya escogido. Si dicho coeficiente no nulo no existiera, la
matriz sera singular.
Esta permutacin de filas es til tambin cuando el pivote es pequeo aunque no nulo. Valores
pequeos del pivote pueden producir grandes errores de redondeo, ya que siempre se divide
por el valor del pivote. Por consiguiente, para reducir los errores de redondeo conviene escoger
el pivote mximo en valor absoluto. Para ello, hay dos tcnicas:
1. En el k-simo sistema se toma como pivote el coeficiente mayor en valor absoluto de la
columna k situado por debajo de la fila k inclusive. Para ello se permutan las filas k y la del
al pivote escogido y sus trminos independientes. Esta tcnica se denomina mtodo de
Gauss con pivoteo parcial.
2. En el k-simo sistema, se toma como pivote el coeficiente mayor en valor absoluto de la
submatriz de orden n-k definida por los coeficientes que quedan por debajo de la fila k y a
la derecha de la columna k. Para ello, se permutan la fila k (y el trmino independiente
asociado) y la columna k con las del pivote escogido. Al final del proceso deben ponerse en
el orden inicial las componentes del vector solucin, puesto que su posicin ha sido
modificada al realizar las permutaciones de columnas. Esta tcnica es el mtodo de Gauss
con pivoteo total.
Estas dos estrategias producen mtodos numricamente estables. El mtodo de Gauss sin
pivoteo no es necesariamente estable. En la prctica el pivoteo total no suele hacerse pues la
mejora obtenida no compensa la mayor complejidad.
A continuacin se presenta el algoritmo del mtodo de Gauss con pivoteo parcial
for j=1:n-1
[pivote, fila_pivote]=max(abs(A(j:n,j)); % Busca la fila pivote
fila_pivote=fila_pivote+j-1;
if abs(pivote)< 10*eps
Msgbox(Matriz singular); % Matriz singular
Return;
end
if fila_pivote(j)~=j
Aux=A(j,:); % Intercambia las filas
A(j,:)=A(fila_pivote,:);
A(fila_pivote,:)=Aux;
temp=b(j); % y los trminos independientes
b(j)=b(fila_pivote);
b(fila_pivote)=temp;
end
for i=j+1:n % almacena los multiplicadores en
A(i,j)=A(i,j)/A(j,j); % los lugares de A que se anularn
A(i,j+1:n)=A(i,j+1:n)-A(i,j)*A(j,j+1:n); % transforma las filas
b(i)=b(i)-A(i,,j)*b(j); % y trminos independientes
end
end
x(n)=b(n)/A(n,n); % Comienza sustitucin hacia atrs
for j=n-1:-1:1
x(j)=(b(j)-sum(x(j+1:n).*A(j,j+1:n)))/A(j,j);
end
2.3.3 Mtodos de descomposicin triangular
Si analizamos el mtodo de Gauss sin pivoteo desde un punto de vista matricial, podemos ver
que con este algoritmo obtenemos una matriz triangular superior U a partir de A mediante
U = A
(n-1)
= GA = G
(n-1)
G
(n-2)
G
(1)
A , siendo
(
(
(
(
(
(
(
(
(
=
+
1 0 0 0
0 1 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1
, 1
) (
L L
M O M M M M
L L
L L
L L
M M M M O M
L L
nk
k k
k
l
l
G ,
o sea que descompusimos A como A = LU donde U es triangular superior y
( ) ( ) ( )
(
(
(
(
(
(
= = =
1 ...
0 1
0 0 1
0 0 0 1
1 , 2 1
2 , 1 1 , 1
21
1
) 1 (
1
) 2 (
1
) 1 ( 1
n n n n
n n
n
l l l
l l
l
L
M M O M M
L
L
LG G G G L es triangular inferior.
Ejemplo
Del ejemplo anterior podemos verificar que:
(
(
(
(
(
(
=
(
(
(
80 . 1 0 0
75 . 4 5 . 2 0
1 2 4
1 2 . 0 25 . 0
0 1 75 . 0
0 0 1
3 1 1
4 1 3
1 2 4
En caso de usar pivoteo parcial, LU ser una permutacin de las filas de A, es decir PA = LU ,
siendo P es una matriz de permutacin.
Obsrvese que cualquier algoritmo que permita descomponer A como PA = LU siendo P una
matriz de permutacin, L triangular inferior y U triangular superior, permite transformar el
problema Ax = b en
=
=
y Ux
Pb Ly
resolviendo Ly = Pb por sustitucin hacia delante para obtener y, y luego Ux = y por sustitucin
hacia atrs para obtener x.
Estos algoritmos de descomposicin triangular no son ms que variantes del mtodo de
Gauss en las que se reordenan las operaciones, por lo que sus caractersticas (existencia de
soluciones, necesidad de pivoteo, etc.) son las mismas.
La diferencia ms importante es que en el mtodo de Gauss las operaciones sobre el trmino
independiente se hacen simultneamente con la fase de eliminacin, mientras que en los
mtodos de descomposicin primero se hace la descomposicin y luego se opera sobre el
trmino independiente para obtener y (que no es ms que el b modificado que se obtiene en la
fase de eliminacin). Luego en ambos casos se pasa a la fase de sustitucin hacia atrs.
Esto hace que los mtodos de descomposicin sean adecuados para resolver sucesivamente
varios problemas con la misma matriz y diferentes trminos independientes, pues una vez
hecha la descomposicin basta con repetir las fases de sustitucin hacia adelante y atrs para
cada trmino independiente
3
.
Veremos mtodos sin pivoteo. Supondremos que A puede descomponerse como A=LU con L
triangular inferior y U triangular superior, es decir
n j i u l a
n
k
kj ik ij
,..., 1 ,
1
= =
=
con
> =
> =
j k u
i k l
kj
ik
0
0
por tanto si i = j + = =

= =
ii ii
i
k
ki ik
i
k
kj ik ii
u l u l u l a
1
1 1
2-6

=
=
1
1
i
k
ki ik ii ii ii
u l a u l
si i > j entonces + = =

= =
jj ij
j
k
kj ik
j
k
kj ik ij
u l u l u l a
1
1 1
2-7
jj
j
k
kj ik ij
ij
u
u l a
l
=
1
1
y si i < j + = =

= =
ij ii
i
k
kj ik
i
k
kj ik ij
u l u l u l a
1
1 1
2-8
ii
i
k
kj ik ij
ij
l
u l a
u
=
1
1
Obsrvese que estas ecuaciones se pueden resolver directamente si se alterna la eleccin de
elementos diagonales de L y de U que verifiquen 2-6, el clculo de las columnas de L segn
2-7 de las filas de U segn 2-8.
Por supuesto, si para algn i el segundo miembro de 2-6 se anula, algn elemento diagonal de
L o U deber ser nulo y el algoritmo no podr terminarse. En esos casos ser necesario
realizar pivoteo, lo cual complica bastante las cosas y no lo veremos.

3
esto es especialmente til para el mtodo de mejora de la solucin que se ve en 2.3.5
2.3.3.2 Mtodo de Crout
Es el caso particular en el que los elementos diagonales de U se hacen valer 1.
En este caso el algoritmo del mtodo puede escribirse como:
L(:,1)=A(:,1); % Primera columna de L
U(1,:)=A(1,:)/L(1,1); % Primer fila de U
for j=2:n
U(j,j)=1;
for i=j:n
L(i,j)=A(i,j)-sum(L(i,1:j-1).*U(1:j-1,j)) ; %Calcula col. L
end
for i=j+1:n
U(j,i)=(A(i,j)-sum(L(j,1:j-1).*U(1:j-1,i)))/L(j,j); %Calc. fila U
end
end
y(1)=b(1)/L(1,1); %Comienza sustitucin hacia adelante
for i=2:n
y(i)=(b(i)-sum(L(i,1:i-1).*y(1:i-1)))/L(i,i);
end
x(n) = y(n)/U(n,n); %Comienza sustitucin hacia atrs
for i=n-1:-1:1
x(i)=(y(i)-sum(U(i,i+1:n).*x(i+1:n)));
end
Ntese que cada elemento de A slo se usa para calcular
4
un elemento de L o de U y no se
vuelve a usar, por lo que podran almacenarse los elementos calculados en las mismas
variables que contenan los elementos de A. Esta tcnica reduce a la mitad la memoria
necesaria.
La cantidad de operaciones del mtodo de Crout es (4n
3
-3n
2
-n)/6 en la fase de descomposicin
y 2n
2
-n en la fase de sustitucin, totalizando la misma cantidad que el mtodo de Gauss,
Ejemplo
Consideremos el caso
(
(
(
=
(
(
(
=
2
11
12
1 2 2
3 2 1
2 1 3
b A y
se obtiene la descomposicin
(
(
(

=
(
(
(

=
1 0 0
1 1 0
3 / 2 3 / 1 1
1 3 / 4 2
0 3 / 7 1
0 0 3
U L y
y en la fase de sustitucin
(
(
(
=
(
(
(
=
2
1
3
2
3
4
x y y

4
Basta con realizar las sumas con variables de doble precisin para minimizar los errores de redondeo, aunque luego el
resultado se almacene en variables de simple precisin.
2.3.3.3 Mtodo de Doolitle
Es muy similar al de Crout. En este caso son los elementos diagonales de L que se hacen valer
1, dando exactamente el mismo resultado que la escalerizacin por el mtodo de Gauss.
Este es el mtodo usado por Matlab en la funcin [L, U, P]=lu(A) , que realiza la descompsicin
PA=LU siendo P una matriz de permutacin que corresponde al pivotaje.
Usando esta funcin se puede resolver el sistema Ax=b mediante:
[L,U,P]=lu(A) % descompone A
y=L\(P*b) % resuelve sistema L
x=U\y % resuelve sistema U
2.3.3.4 Mtodo de Cholesky
En muchas aplicaciones se presentan sistemas en los que la matriz A es simtrica y definida
positiva. En estas condiciones puede demostrarse que A se puede descomponer como A= LL
T
.
El mtodo de Cholesky resuelve este caso. Sabiendo que U = L
T
las ecuaciones quedan:
2-9 1
1
1
2
,n , j l a l
j
k
jk jj jj
= =

=
2-10
,n , j i
,n , j
l
l l a
l
jj
j
k
jk ik ij
ij
+ =
=
=
1
1
1
1
Y podemos escribir el siguiente algoritmo:
L(1,1)=sqrt(A(1,1));
L(2:n,1)=A(2:n,1)/L(1,1); % Primera fila de L
for j=2:n
L(j,j)=sqrt(A(j,j)- sum(L(j,1:j-1)^2); % Elemento diagonal
for i=j+1:n
L(i,j)=(A(i,j)-sum(L(i,1:j-1).*L(j,1:j-1))/L(j,j); %Calc. fila L
end
end
for i=2:n
y(i)=(b(i)-sum(L(i,1:i-1).*y(1:i-1)))/L(i,i);
end
x(n) = y(n)/L(n,n); %Comienza sustitucin hacia atrs
for i=n-1:-1:1
x(i)=(y(i)-sum(L(i+1:n,i).*x(i+1:n)))/L(i,i);
end
Ntese que adems de las ventajas del mtodo de Crout, en el de Cholesky se puede
almacenar slo media matriz A y en la misma memoria almacenar la L.
La cantidad de operaciones del mtodo de Cholesky es (2n
3
+3n
2
-5n)/6 ms n races cuadradas
en la fase de descomposicin y 2n
2
operaciones en la fase de sustitucin.
Ejemplo
Si aplicamos este mtodo al sistema del ejemplo de transmisin de calor,
(
(
(
(
(
(
(
(
(
(
(
(
=
(
(
(
(
(
(
(
(
(
(
(
(

=
150
50
50
100
0
0
150
50
50
4 1 0 1 0 0 0 0 0
1 4 1 0 1 0 0 0 0
0 1 4 0 0 1 0 0 0
1 0 0 4 1 0 1 0 0
0 1 0 1 4 1 0 1 0
0 0 1 0 1 4 0 0 1
0 0 0 1 0 0 4 1 0
0 0 0 0 1 0 1 4 1
0 0 0 0 0 1 0 1 4
b A y
Se obtiene
(
(
(
(
(
(
(
(
(
(
(
(
=
8284 . 1 6014 . 0 0146 . 0 5430 . 0 0 0 0 0 0
0 8315 . 1 5679 . 0 1716 . 0 5418 . 0 0 0 0 0
0 0 9249 . 1 0519 . 0 1555 . 0 5176 . 0 0 0 0
0 0 0 8417 . 1 5833 . 0 0092 . 0 5175 . 0 0 0
0 0 0 0 8457 . 1 5546 . 0 138 . 0 5164 . 0 0
0 0 0 0 0 9319 . 1 0345 . 0 1291 . 0 5 . 0
0 0 0 0 0 0 9322 . 1 5164 . 0 0
0 0 0 0 0 0 0 9365 . 1 5 . 0
0 0 0 0 0 0 0 0 2
L
(
(
(
(
(
(
(
(
(
(
(
(
=
(
(
(
(
(
(
(
(
(
(
(
(
=
8571 . 67
0000 . 50
1429 . 32
4286 . 71
0000 . 50
5714 . 28
8471 . 67
0000 . 50
1429 . 32
0744 . 124
7673 . 50
4829 . 32
5489 . 84
5350 . 18
1678 . 10
2582 . 86
2749 . 32
0000 . 25
x y y
2.3.3.5 Aplicacin a matrices tridiagonales
Las matrices tridiagonales son en las que los nicos elementos no nulos son los de la diagonal
principal y sus dos diagonales adyacentes. Son bastante frecuentes en sistemas lineales que
aparecen en ciertos problemas de Ingeniera.
Como los elementos alejados de la diagonal son nulos, las frmulas 2-6, 2-7 y 2-8 se
simplifican pues las sumatorias tienen slo uno o ningn sumando no nulo, quedando:
i i i i ii ii ii
u l a u l
, 1 1 ,
=
1 0
1 , 1
1 ,
1 ,
< = =

i j l
u
a
l
ij
i i
i i
i i
y
1 0
1 ,
1 ,
+ < = =
+
+
i j u
l
a
u
ij
ii
i i
i i
por lo que las matrices triangulares slo tendrn elementos no nulos en la diagonal principal y
una diagonal adyacente.
Esto disminuye dramticamente la cantidad de operaciones necesarias a 8n-7.
A continuacin se muestra un algoritmo del Mtodo de Crout para matrices tridiagonales.
L(1,1)=A(1,1); % Primera columna de L
U(1,2)=A(1,2)/L(1,1); % Primer fila de U
for j=2:n
L(j,j-1)=A(j,j-1);
L(j,j)=A(j,j)-L(j,j-1)*U(j-1,j); %Calcula col. L
U(j,j+1)=A(j,j+1)/L(j,j); %Calc. fila U
end
for i=2:n
y(i)=(b(i)-L(i,i-1)*y(i-1))/L(i,i);
end
x(n) = y(n); %Comienza sustitucin hacia atrs
for i=n-1:-1:1
x(i)=y(i)-U(i,i+1)*x(i+1);
end
Obsrvese que slo se calculan los elementos no nulos y los elementos diagonales de U no se
calculan. Esto ahorra mucho espacio si las matrices se almacenan como matrices dispersas, ya
que los elementos no calculados no se almacenan (los diagonales de U se suponen 1 y los
dems se suponen nulos).
2.3.4 Anlisis de error
Cuando se resuelve un sistema Ax = b se espera que la solucin calculada, x*, sea cercana a
la solucin exacta, x. Sin embargo, aunque el algoritmo usado conduzca tericamente a la
solucin exacta, tendremos varias fuentes de error:
1. Errores de medidas de los elementos de A y b. En muchos casos el problema a resolver es
una representacin matemtica de un sistema real, y los elementos de A y b se derivan de
medidas de caractersticas del sistema real y por tanto estn sujetos a errores de medida.
2. Errores de representacin de los elementos de A y b al ser almacenados con una cantidad
finita de dgitos.
3. Errores de redondeo debidos a que las operaciones aritmticas generarn nmeros con
ms dgitos que los que se pueden almacenar y debern redondearse.
Veremos cmo podemos estimar el error.
2.3.4.1 Sistemas mal condicionados
A priori parece razonable pensar que si definimos el residuo como r = b - Ax*, cuando el
residuo sea pequeo el error x = x - x* ser pequeo
Esto no es as en sistemas mal condicionados, que dan residuos pequeos para soluciones
calculadas con error significativo.
Por ejemplo, si
(
=
1441 2161
8648 2969 1
. .
. .
A y
(
=
1440 .
8642 . 0
b
podramos obtener la solucin calculada x*=(0.9911 , -0.4870) y si evaluamos su residuo
obtenemos b=(-10
-8
, 10
-8
) , lo cual nos puede hacer pensar que el error es pequeo, sin
embargo la solucin exacta es x=(2 , -2) .
Esto se debe a que el problema es mal condicionado pues la matriz A es casi singular y
cualquier vector que satisfaga una de las ecuaciones dar muy bajo residuo en la otra (que es
casi un mltiplo de la anterior).
Adicionalmente los problemas mal condicionados usualmente implican que se obtendrn
elementos pivotes cercanos a cero por resta de nmeros casi iguales, lo cual produce errores
relativos por redondeo muy importantes. Si bien esto puede postergarse mediante pivoteo, ser
inevitable que el ltimo elemento pivote sea cercano a cero y su error de redondeo se
propagar en la sustitucin hacia atrs.
Es ms, el mtodo de Gauss con pivoteo dar casi siempre bajos residuos, ya que la matriz U
tiene elementos diagonales (con la posible excepcin del ltimo) con valor absoluto
relativamente grande (ya que para eso se hace el pivoteo), y al obtener x
1
, x
2
,,x
n-1
por
sustitucin hacia atrs, las ecuaciones correspondientes se satisfarn con un bajo residuo sin
importar lo exacto que sea x
n
.
2.3.4.2 Normas de vectores y matrices
Para comparar el tamao de los errores y los residuos usaremos normas.
En espacios vectoriales una norma es una funcin R E : tal que:
y x, y x y x
x x x
0 x 0 x x, 0 x
+ +
=
= =
,
En espacios de matrices se pide tambin que la norma cumpla B A, B A AB .
Si una norma de matrices y una de vectores cumplen que x A, x A Ax , se dice
que son consistentes.
Para toda norma de vectores existe al menos una norma de matrices consistente con ella, a
saber
Ax
x
Ax
A
1 0 =
= =
x x
max max
Tres casos muy usados de normas de vectores son:
=
=
n
i
i
x
1
1
x
=
=
n
i
i
x
1
2
2
x (Norma Eucldea)
i
i
max x x =
y sus correspondientes normas matriciales son:
=
=
n
i
ij
j
a max
1
1
A
1
2
= A siendo
1
el mximo valor propio de A
T
A (Norma espectral)
=
n
j
ij
i
a max
1
A
2.3.4.3 Anlisis de perturbaciones
5
Trataremos de estimar el efecto que tiene una perturbacin en A o en b sobre el error de x.
Perturbacin en b:
( ) ( ) = = + = +

b A x b x A b b x) A(x
1
2-11 b A x
1

por otro lado = x b b x
2-12
b
x

1
Combinando 2-11 y 2-12 se obtiene
2-13
b
b
A
b
b
A A
x
x
1

=

) (
donde
1
A A A

) ( es el nmero de condicin de A.
El nmero de condicin de una matriz es siempre mayor o igual a la unidad. Si el nmero de
condicin es grande se dice que el problema es mal condicionado.
Perturbacin en A:
En forma similar se demuestra que si = + + b x) A)(x (A
2-14
A
A
(A)
x x
x
Las desigualdades 2-13 y 2-14 nos dicen que para problemas mal condicionados, pequeos
errores en la matriz o el trmino independiente pueden causar grandes errores en la solucin,
mientras que para problemas bien condicionados nos asegura buena precisin.
2.3.4.4 Errores de redondeo
Las desigualdades 2-13 y 2-14 slo sirven para acotar la parte del error de la solucin debida a
errores en los valores de A o b, pero aunque A y b no tengan errores, debido a los errores de
redondeo generados durante las operaciones aritmticas, o a errores de truncacin del mtodo,
la solucin obtenida, x*, tendr error.
Se define el residuo de x* como r=b-Ax*
= = = = =

r A x x A x*) - A(x Ax* - Ax Ax* - b r
1
) (
2-15 r A x
1
y, combinando 2-15 y 2-12,

2-16
b
r
A
b
r
A A
x
x
1
) ( =

Obsrvese que el error (x) que aparece en 2-16 es el error total de la solucin e incluye
errores de cualquier fuente (errores de datos, redondeo, truncacin, fallos, etc.)
La experiencia muestra que para mtodos directos y si no hay errores en A y b, en general

maq
n
b
r

5
Este anlisis es vlido para cualquier par de normas vectorial y matricial consistentes, pero suele usarse la norma 1 o
la norma infinito por ser fciles de evaluar.
2-17 ) (A
x
x

maq
n

6
La desigualdades 2-16 y 2-17 nos dicen que un residuo pequeo o un psilon de mquina
pequeo no necesariamente implica que el error en la solucin sea pequeo para problemas
mal condicionados, pero s para problemas bien condicionados.
El problema es que para calcular el nmero de condicin habra que invertir la matriz del
sistema, lo cual tiene mucho costo de clculo. Ms adelante veremos cmo estimar el nmero
de condicin.
2.3.5 Mejora de la solucin y estimacin del nmero de condicin
Veremos una forma de estimar el nmero de condicin y de paso mejorar la solucin calculada.
Una vez obtenida una solucin calculada x* podemos evaluar el residuo r=b-Ax* (esto debe
hacerse con aritmtica de alta precisin para evitar errores por resta de nmeros casi iguales) y
a continuacin calcular el error resolviendo Ax=-r, lo cual no es muy costoso pues ya tenemos
la descomposicin triangular de A y slo hay que hacer las sustituciones hacia adelante y hacia
atrs.
Una vez obtenido x podemos mejorar la solucin mediante x
(2)
=x*-x y adems estimar el
nmero de condicin a partir de 2-16 segn
2-18
) 2 (
) (
x
x
r
b
A

Ejemplo
Se tiene el sistema
(
(
(
=
(
(
(
58 . 2
22 . 5
28 . 5
32 . 2 11 . 2 85 . 1
98 . 0 77 . 6 53 . 2
11 . 2 06 . 1 23 . 4
x
Usando aritmtica de tres dgitos con truncacin, se obtiene x*=(0.991, 0.997, 1.00)
T
.
Si calculamos Ax* y el residuo con aritmtica de 6 cifras obtenemos
(
(
(
=
(
(
(
0103 . 0
00246 . 0
0349 . 0
59032 . 2
22246 . 5
24511 . 5
* r Ax
donde expresamos r con 3 dgitos.
Si ahora resolvemos Ax=-r del mismo modo que antes, obtenemos
(
(
(
(
= =
(
(
(
(
=
00 . 1
00 . 1
999 . 0
*
00000757 . 0
00300 . 0
00822 . 0
) 2 (
x x x x y
y podemos estimar el nmero de condicin usando 2-18 .
24 . 1
00 . 1
00822 . 0
0349 . 0
28 . 5
) (
) 2 (
= =
x
x
r
b
A

Con lo cual confirmamos que este problema es bien condicionado

7
.

6
Este resultado es aproximado y slo sirve para estimar el orden de magnitud del nmero de condicin.
7
El nmero de condicin verdadero es 17.6, algo mayor que el estimado.
2.3.6 Clculo de determinantes
Un resultado adicional que se obtiene a partir de cualquiera de estos mtodos con muy bajo
esfuerzo es el clculo del determinante de la matriz A.
Si PA=LU entonces det(P).det(A)=det(L).det(U), lo cual permite calcular el determinante de A
como:
|
|
\
|
|
|
\
|
=

= =
n
i
ii
n
i
ii
l u det
1 1
) (A
siendo el signo negativo si la cantidad de permutaciones de P es impar y positivo si es par.
2.4 Mtodos Iterativos
Estos mtodos parten de una primera solucin aproximada a la que se le hacen sucesivas
mejoras hasta obtener una solucin con la precisin deseada.
Suelen aplicarse a sistemas con matrices grandes y vacas, pues como estos mtodos no
modifican la matriz sino que trabajan siempre con la matriz original, aprovechan su condicin
de vaca para almacenar slo los elementos no nulos y operar slo con ellos
Se basan en convertir el problema Ax=b en uno equivalente de la forma x=f(x)=Tx+c tal que la
funcin f sea contractiva
8
.
Partiendo de una aproximacin inicial x
(0)
se define la sucesin {x
(k)
} / x
(k+1)
=Tx
(k)
+c, que
converge al punto fijo de f , x* / f(x*)=x* y por tanto es solucin del problema.
2.4.1 Mtodo de Jacobi
Supongamos que los elementos diagonales de A son no nulos (o reordenemos las ecuaciones
para que lo sean). Podemos despejar de cada ecuacin la variable correspondiente obteniendo
el sistema equivalente
n i
a
x a b
x
ii
n
i j
j
j ij i
i
,..., 2 , 1
1
=
=
El mtodo de Jacobi consiste en calcular la sucesin de aproximaciones definida por
2-19 n i
a
x a b
x
ii
n
i j
j
k
j ij i
k
i
,..., 2 , 1
1
) (
) 1 (
=
=
+
partiendo de una aproximacin inicial x
(0)
, que usualmente se toma como el vector nulo.
Este mtodo tambin se llama de desplazamientos simultneos, pues los nuevos valores
calculados de cada componente de x desplazan a los anteriores todos simultneamente al
terminar una iteracin.
El error puede estimarse por la norma de la diferencia entre una aproximacin y la anterior.
El algoritmo puede escribirse como sigue.
x(:)=zeros(n,1); % aproximacin inicial
iter=1;
error=tol+1;
while(error>tol & iter<maxiter)
for i=1:n
xnuevo(i)=(b(i)-sum(A(i,1:i-1).*x(1:i-1))-
-sum(A(i,i+1:n).*x(i+1:n)))/A(i,i); % nueva solucin
end

8
si B es cerrado, f:BB es contractiva sii B b a b a m b f a f m < , ) ( ) ( / 1 0
error=norm(xnuevo(:)-x(:),inf); % estima error
iter=iter+1;
x(:)=xnuevo(:); % desplazamiento
end
Ejemplo
Se tiene el sistema
= +
= + +
= +
1 5 2
5 2 7 2
11 2 6
3 2 1
3 2 1
3 2 1
x x x
x x x
x x x
la iteracin de Jacobi queda
+ + =
+ =
+ =
+
+
+
) (
2
) (
1
) 1 (
3
) (
3
) (
1
) 1 (
2
) (
3
) (
2
) 1 (
1
4000 . 0 2000 . 0 200 . 0
2857 . 0 2857 . 0 7143 . 0
1667 . 0 3333 . 0 8333 . 1
k k k
k k k
k k k
x x x
x x x
x x x
Empezando con el vector nulo como aproximacin inicial se obtienen las aproximaciones que
se muestran en Tabla 1
Iteracin 0 1 2 3 4 5
x
1
0 1.833 2.038 2.085 2.004 1.994
x
2
0 0.714 1.181 1.053 1.001 0.990
x
3
0 0.200 0.852 1.080 1.038 1.001
Tabla 1 Iteraciones por el mtodo de Jacobi
2.4.2 Mtodo de Gauss Seidel
En el mtodo de Jacobi nos abstenemos de usar los nuevos valores de cada componente
hasta completar el clculo de todas ellas. Sin embargo parece razonable pensar que los
nuevos valores sean ms exactos que los viejos y deberan usarse lo antes posible.
Usando en 2-19 las componentes ya calculadas obtenemos el mtodo de Gauss Seidel
2-20 n i
a
x a x a b
x
ii
n
i j
k
j ij
i
j
k
j ij i
k
i
,..., 2 , 1
1
) (
1
1
) 1 (
) 1 (
=

=

+ =
=
+
+
Este mtodo usualmente converge ms rpido que el de Jacobi.
El algoritmo se puede escribir:
x(:)=zeros(n,1); % aproximacin inicial
iter=1;
error=tol+1;
while(error>tol & iter<maxiter)
error=0
for i=1:n
aux=(b(i)-sum(A(i,1:i-1).*x(1:i-1))-
-sum(A(i,i+1:n).*x(i+1:n)))/A(i,i); % nueva solucin
error=max(abs(x(i)-aux), error)
x(i)=aux % desplazamiento
end
iter=iter+1;
end
Ejemplo
Aplicando Gauss Seidel al mismo sistema del ejemplo anterior, la iteracin quedara:
+ + =
+ =
+ =
+ + +
+ +
+
) 1 (
2
) 1 (
1
) 1 (
3
) (
3
) 1 (
1
) 1 (
2
) (
3
) (
2
) 1 (
1
4000 . 0 2000 . 0 200 . 0
2857 . 0 2857 . 0 7143 . 0
1667 . 0 3333 . 0 8333 . 1
k k k
k k k
k k k
x x x
x x x
x x x
Empezando con el vector nulo como aproximacin inicial se obtienen los resultados de Tabla 2
Iteracin 0 1 2 3 4 5
x
1
0 1.833 2.069 1.998 1.999 2.000
x
2
0 1.238 1.002 0.995 1.000 1.000
x
3
0 1.062 1.015 0.998 1.000 1.000
Tabla 2 Iteraciones por el mtodo de Gauss Seidel
como puede verse converge ms rpido que Jacobi.
2.4.3 Convergencia
Si descomponemos la matriz A como la suma de su diagonal, tringulo inferior y superior,
A = L+D+U Ax = (L+D+U)x = b
En el mtodo de Jacobi despejanos x segn Dx = b-(L+U)x x = D
-1
b - D
-1
(L+U)x = T
J
x+c
J
con T
J
= - D
-1
(L+U) y c
J
= D
-1
b
En el mtodo de Gauss Seidel (L+D)x = b-Ux x = (L+D)
-1
b (L+D)
-1
Ux = T
GS
x+c
GS
con T
GS
= (L+D)
-1
U y c
GS
= (L+D)
-1
b
Para que la funcin de la iteracin sea contractiva basta que la norma de la matriz T
correspondiente sea menor que uno.
Si A es diagonalmente dominante por filas,
1 < = = >
ii
i j
ij
i
i j ii
ij
i
J
i j
ij ii
a
a
max
a
a
max a a T
lo cual demuestra que el mtodo de Jacobi converge si A es diagonalmente dominante por
filas.
En el caso de Gauss Seidel, x T y y
GS
= /
y = (L+D)
-1
Ux -(L+D)y = Ux -Dy = Ux+Ly
sea =
i
y i y /

+ =
+ =
= + =
+ + + = =
n
i j
ij
i
j
ij
n
i j
j ij
i
j
j ij
n
i j
j ij
i
j
j ij i ii ii
a a x a y a x a y a y a a
1
1
1 1
1
1 1
1
1
x y y
ii
i
j
ij
i
ii
n
i j
ij
i
i
i
i i
a
a
s y
a
a
r donde
s
r
s r

= + =

= =
+
1
1 1
1
x y y x y
Si A es diagonalmente dominante por filas, entonces
1
1
1
1
1
0
<
= <
< +
i
i
i x
GS
i
i
i i
s
r
max max
s
r
i s r
x
y
T
lo cual demuestra que el mtodo de Gauss Seidel converge si A es diagonalmente dominante
por filas.
Tambin puede demostrarse que si A es simtrica y definida positiva entonces el mtodo de
Gauss Seidel converge.
Como se ver ms adelante, si 1 < = m T entonces se puede acotar el error segn
2-21
m
m
m
k k k

+ +
1 1
*
1
* *
1
x x r x
donde es una cota del error absoluto de evaluacin de Tx

2-Sistemas de Ecuaciones Lineales

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

2-Sistemas de Ecuaciones Lineales

Caricato da

Copyright:

Formati disponibili

Universidad de Montevideo

Sistemas de ecuaciones lineales 2-5

y sus correspondientes normas matriciales son:

y, combinando 2-15 y 2-12,

Con lo cual confirmamos que este problema es bien condicionado

Potrebbero piacerti anche