Está en la página 1de 31

MN50 - Computaciones de altas prestaciones

Matlab
Practicas 1 : Resolucin de
sistemas de cuaciones lineales











David Perrin
ETSII / UTBM
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 2 -

Sumario


Descomposicin LU (I) 3
Descomposicin LU prematurada 3
Descomposicin LU (II) 4
Descomposicin LU de Matlab 4
Mtodos directos optimizados, generalidades 5
Mtodo Cholesky optimizado 5
Apunte literario para Cholesky (mtodo Gaxpy) 7
Mtodo LU optimizada 8
Apunte literario para LU 9
Ordenes de costes de flops teoricos 10
Resolucin de sistema 11
Mtodo directos, costes relativo al tamao 13
Matrices de Hilbert 16
Nmero de condicin 17
Mtodos iterativos, generalidades 18
Mtodo de Gauss-Seidel (nivel escalar) 19
Mtodo de Jacobi (nivel escalar) 20
Mtodo de Gauss-Seidel (nivel matricial) 21
Mtodo de Jacobi (nivel matricial) 21
Mtodos iterativos, costes relativo al tamao 22
Comparacin costes mtodos directos y iterativos 25
Detecin de la potencia del coste temporal 30
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 3 -
Ejercicio 1
a) Implementa el algoritmo de descomposicin LU visto en teora.

Descomposicin LU (I)

funcin lu_.m:

function [L,U]=lu_(a)
% descomposicion LU sin pivotacion
% a: matriz cuadrada

[n,m]=size(a);
if n~=m error('Matriz no cuadrada.'); end

for j=1:n-1
if a(j,j)==0 error('Pivote nulo.'); end
for i=(j+1):n
factor=a(i,j)/a(j,j);
a(i,j)=factor;
for k=j+1:n
a(i,k)=a(i,k)-factor*a(j,k);
end
end
end
L=tril(a,-1)+eye(n);
U=triu(a);

b) Dada la matriz de coeficientes siguiente, calcula la descomposicin L-U. En
el caso en que el algoritmo termine prematuramente explica la causa
mediante una traza.

A =

|
\

|
.
|
|
|
|
1 2 1 0
2 4 1 1
1 3 0 1
2 4 1 0


Descomposicin LU prematurada

Explicacin:

El pivot del algoritmo LU da un elemento de la diagonal nulo. Con pvot =2, el segundo
paso da A(2,2)=0. Por lo tanto, sin deteccin de pvot adecuado, la descomposicin no
puede hacerse. Entonces eso necesita un paso de deteccin (ref. programa lu_.m, fila 9).

Aplicacin en Matlab:

A=[1 2 1 0;2 4 -1 1;1 3 0 1;2 4 1 0];
lu_(A)
??? Error using ==> lu_
Pivote nulo.

Nota: A(3,3)=A(4,4)=0, no molestan la descomposicn porque se cambian durante el tratamiento.
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 4 -
c) Aplica la descomposicin LU a la matriz A permutando la segunda y tercera
filas. Comenta la razn por la que en este caso el algoritmo LU funciona
correctamente.

Descomposicin LU (II)

Explicacin:

Durante el tratamiento LU, el pvot no da nunca un elemento tal que A(i,i)=0.

Aplicacin en Matlab:

A_=[1 2 1 0;1 3 0 1;2 4 -1 1;2 4 1 0];
lu_(A_)

ans =

1.0000 0 0 0
1.0000 1.0000 0 0
2.0000 0 1.0000 0
2.0000 0 0.3333 1.0000


d) Calcula la descomposicin LU de la matriz A mediante el comando lu de
MATLAB.

Descomposicin LU de Matlab

Explicacin:

La decomposicin LU de matlab funciona mediante una matriz de paso P para evitar
encontrar las situaciones anteriores. En este caso, P es tal que P A L U = .

Nota: En Matlab, el resultado del mando [L,U,P]=lu(A) da:

1 0 0 0
0.5 1 0 0
0 0 1 0
0 0 0.75 1
L
(
(
(
=
(
(

,
2 4 1 1
0 1 0.5 0.5
0 0 2 1
0 0 0 0.25
U
(
(
(
=
(
(

,
0 1 0 0
0 0 1 0
0 0 0 1
1 0 0 0
P
(
(
(
=
(
(



Coste en flops (matriz A con segunda y tercera filas permutadas):

LU teorico practicacs matlab
flops
3
2
43
3
n
44 34

Nota: los algoritmos de Matlab son hiper-optimizados para el clculo matricial
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 5 -
Ejercicio 2

a) Implementa los algoritmos L-U y Cholesky, y despus modifcalos de forma
que se minimice el nmero de operaciones a realizar para resolver un
sistema de ecuaciones lineales cuya matriz de coeficientes tenga una
estructura pentadiagonal simtrica.

Mtodos directos optimizados, generalidades

Introduccin

El principio del optimizacin es el mismo para los dos mtodos de descomposicin: dentro
de cada funcin, introduciremos un parmetro p - el ancho de la banda de la matriz
(aqu, 2
penta
p = ) - y disminuiremos los lmites de los bucles for. Teniendo cuidado con los
lmites de la matriz.

Al nivel de Matlab, hay que saber que el coste en flops incluye las operaciones de las
bucles for. As, a veces, no se nota la diferencia entre el algoritmo optimizado y el
original, o peor an: se puede hacer el invertido, tal que
optimizado original
t t .

Mtodo Cholesky optimizado

Principio:
En el mtodo de Cholesky, la ecuacin regiendo la descomposicin era :
1
k
ik ij kj
j
a g g
=
=



Pues, aqu, teniendo en cuenta el ancho de la banda (p), tendremos :
( ) max 1,
k
ik ij kj
j k p
a g g
=
=



Colocacin en la funcin cholp.m:

function G=cholp(a)
% descomposicion de Cholesky
% a: matriz positive cuadrada simtrica

[n,m]=size(a);
if n~=m error('Matriz no cuadrada.'); end
if sum(sum(a<0,2))~=0 error('Matriz no positiva.'); end
if sum(sum(a~=a',2))~=0' error('Matriz no simetrica.'); end

G=zeros(size(a));
for k=1:n
aux=0;
for j=max(1,k-p):k-1
aux=aux+G(k,j)^2;
end
G(k,k)=(a(k,k)-aux)^.5;
for i=k+1:k+p
aux=0;
for j=max(1,k-p):k-1
aux=aux+G(i,j)*G(k,j);
end
G(i,k)=(a(i,k)-aux)/G(k,k);
end
end
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 6 -
Coste del algoritmo :

Hablando de operaciones intrnsecas al programa, tenemos el esquema siguiente :

for k=1:n
for j=max(1,k-p) k-1
{2 operaciones}
end
{2 operaciones}
for i=k+1min(k+p,n)
for j=max(1,k-p) k-1
{2 operaciones}
end
{2 operaciones}
end
end

Aqu, los lmites de k son { } 1, , 1, , 1, k p p n p n p n = + + . Calcular el coste es lo mismo
que sumar en esos intervalos. Pero en este caso, debemos aadir una condicn tal que
n p p o lo mismo que 2 n p . Este condicin nos garantiza que la suma siguiente
funcionar. En realidad, en el otro caso ( 2 n p < ) es una forma distinta de suma, as
nuestra condicin se adapta al ejercico (matriz pentadiagonal con p=2 y 4 n > ). De tal
manera que obtenemos :

CHOLp
flops =
( ) ( ) ( ) ( ) ( ) ( )
{ }
1
1 1 2 2 1 1 1 1 2
p
k
k k p k p k k k p
=
( + + + + + + + + +


( ) ( ) ( ) ( ) { }
1
1 1 1 2 2 1 1 1 1 1 2
n p
k p
k k p k k

= +
+ + + + + + + + + + (


( ) ( ) ( ) ( ) { }
1
1 1 1 2 2 1 1 1 1 1 2
n
k n p
k n k k
= +
+ + + + + + + + + (



a ( ) ( ) ( ) ( ) ( )
2
2
1 1 1
2 1 1 2 1 2 1
p n p n
CHOLp
k k p k n p
flops p p k k n k n

= = + = +
| |
( = + + + + + + +
|

\ .



Como ( ) ( )
( )( )
1
1
2 5 1
2 2
2
n p
n p
k p
p
n p n
k k dk

= +
+
+
+ + =



Y ( ) ( ) ( )
( )
( ) ( )( )
2
2
1
1
1
1 3 2 2 2 5 1
6
n
n
k n p
n p
n
k n k f k dk n n n p n p
= +
+

(
= + +




( ) ( )( )( ) ( ) ( ) ( )( ) ( )
2 2 1
2 1 1 2 5 1 1 3 2 2 2 5 1 4 1
3
CHOLp
flops p p p n p n n n n n p n p p n
(
= + + + + + + + + +


UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 7 -
Utilizando el clculo simblico de matlab con que la expresin anterior, es decir el
mando :

>> Syms n p; pretty(simplify(
CHOLp
flops (

));

Da resultado en
4
n . Eso no puede ser as, porque da un resultado negativo. Error ?
Para las comparaciones, nos serviremos del coste de Gaxpy seguramente cerca del nuestro.

Apunte literario para Cholesky (mtodo Gaxpy)

En la literatura
1
, se encuentra una versin optimizada del algoritmo de Cholesky para
matriz con banda.

funcin gaxpy.m:

function G=gaxpy(a,p)
% descomposicion de Cholesky (version Gaxpy)
% a: matriz positive cuadrada simtrica
% p: ancha de la banda

[n,m]=size(a);
if n~=m error('Matriz no cuadrada.'); end
if sum(sum(a<0,2))~=0 error('Matriz no positiva.'); end
if sum(sum(a~=a',2))~=0' error('Matriz no simetrica.'); end
if p>n error('Ancha de banda inadecuada.'); end

G=zeros(size(a));
for k=1:n
aux=0;
for j=max(1,k-p):k-1
i=min(j+p,n);
a(k:i,k)=a(k:i,k)-a(k,j)*a(k:i,j);
end
i=min(k+p,n);
a(k:i,k)=a(k:i,k)/a(k,k)^.5;
end
G=tril(a);

Coste del algoritmo :

Este versin del algoritmo de Cholesky es tambin conocida como la de Gaxpy, hiper-
optimizada para matrices positivas, simtricas y de ancha de banda p.

El coste temporal y en flops del algoritmo de Gaxpy es del orden de
( )
2
3 n p p +

1
Gene H.Golub y Charles F.Van Loan.- Matrix Computations 3th edition.- Johns Hopkins
University Press.- Baltimore, Maryland :1996. [BUPV]
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 8 -
Mtodo LU optimizado

Principio:

Dada una j - elemento de columna -, despus de recorrer j+p los elementos siguientes son
0, par eso limitaremos cada bucle dependiente de j antiguamente:
1
n
j +



De tal forma que tengamos:
( ) min ,
1
j p n
j
+
+



Colocacin en la funcin lup.m:

function [L,U]=lup(a,p)
% descomposicion LU sin pivotacion optimizada
% a: matriz cuadrada
% p: anchura de la tira

[n,m]=size(a);
if n~=m error('Matriz no cuadrada.'); end

flops(0);
for j=1:n
if a(j,j)==0 error('Pivote nulo.'); end
for i=j+1:min(j+p,n)
factor=a(i,j)/a(j,j);
a(i,j)=factor;
for k=j+1:min(j+p,n)
a(i,k)=a(i,k)-factor*a(j,k);
end
end
end
flops
L=tril(a,-1)+eye(n);
U=triu(a);

Coste del algoritmo:

Hablando de operaciones intrnsecas al programa, tenemos el esquema siguiente :

for j=1:n-1
for i=j+1min(j+p,n)
{1 operacion}
for k=j+1min(j+p,n)
{2 operaciones}
end
end
end

Aqu, los lmites de j son { } 1, , 1, j n p n p n = + . Como precedente eso da un total de

( ) ( ) ( ) ( )
2 2
1 1
1 1 2 1 1 2
n p n
LUp
j j n p
flops j p j n j

= = +
= + + + + + +


UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 9 -
Tambin igual a ( )
2
2
1 1
2
n p n
LUp
j j n p
flops p n j

= = +
| |
= +
|
\ .


Introduciendo J n j = , tenemos ( )
1
2 2
1
2
p
LUp
J
flops n p p J
+
=
| |
= +
|
\ .


Y como
( )
3
1
1
2 2
1
1
1 1
3
p
p
J
p
J J dJ
+
+
=
+
=



Entonces al final ( )
3
2
2
2 1
3
LUp
p
flops p p n
| |
+ +
|
\ .

O sea un coste del orden de
2
2np

Apunte literario para LU

En la literatura
2
, se encuentra una versin optimizada de la descomposicin LU.

funcin lupq.m :

function [L,U]=lupq(a,p,q)
% descomposicion LU sin pivotacion optimizada
% a: matriz cuadrada
% p: anchura de la tira sup
% q: anchura de la tira sup


[n,m]=size(a);
if n~=m error('Matriz no cuadrada.'); end

flops(0);
for j=1:n-1
if a(j,j)==0 error('Pivote nulo.'); end
for i=j+1:min(j+p,n)
a(i,j)=a(i,j)/a(j,j);
end
for k=j+1:min(j+q,n)
for i=j+1:min(j+p,n)
a(i,k)=a(i,k)-a(i,j)*a(j,k);
end
end
end
flops
L=tril(a,-1)+eye(n);
U=triu(a);

Coste del algoritmo :

Este versin del algoritmo de LU permite la descomposicin de matrices teniendo un
ancho de banda superior p y un ancho de banda inferior q, tal que n p y n q .

El coste temporal y en flops de este algoritmo es del orden de 2npq .

Nota: Fjase que si p=q, encontramos bien el coste del algoritmo LU anterior:
2
2np

2
Gene H.Golub y Charles F.Van Loan.- Matrix Computations 3th edition.- Johns Hopkins
University Press.- Baltimore, Maryland :1996. [BUPV]
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 10 -
rdenes de costes de flops toricos

Tabla recapitulativa :

flops LU Cholesky
original
3
2
3
n

3
3
n

optimizado
2
2np ( )
2
3 n p p +
apunte
2npq
( )
2
3 n p p +

Grfico de evoluciones:

coste en flop (matriz pentadiagonal)
0
50
100
150
200
250
300
350
400
3 4 5 6 7 8 9 10 11 12 13 14 15
n
flops
Lu Lup Chol Cholp


Observaciones:

Para una matriz pentadiagonal, es decir p=2, la ventaja del mtodo Cholesky optimizado
no se nota. Eso se encontrar cuando tengamos:

LUp Cholp
flops flops > o sea
( )
2 2
2 3 np n p p > + , siendo an
2
3 0 p p > equivalente a 3 p >

Entonces, para una matriz simtrica y positiva, de ancho de banda superior a 3,
tendremos una ventaja para utilizar el mtodo Cholesky optimizado.

Nota: para p=3 y para cualquier n, tenemos
LUp Cholp
flops flops =
(para A simtrica y positiva...)
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 11 -
b) Aplica los algoritmos a la resolucin del sistema obtenido calculando la
matriz de coeficientes con la funcin A=Penta(50) y el trmino
independiente con la funcin b=crea_b(A)

Nota: Para resolver los sistemas triangulares Ly=b, y Ux=y puedes utilizar el operador \ (ver help slash)
(Ejemplo: Ly=b se resolvera con el comando y=L\b)

Resolucin de sistema

Operaciones que realizar:

Cholesky LU
( )
\
\
t
t
Ax b
G G x b
y G b
x G y
=
=
=

( )
\
\
Ax b
L U x b
y L b
x U y

=
=
=



*con una matriz P: \ y L Pb =

Programa de arranque

Para cada algoritmo, Matlab efectuar varios ensayos (aqu 10) para estimar la media
del coste en tiempo CPU con la funcin tic y toc. Por eso utilizaremos un programa de
arranque.

Sea el programa siguiente con n el tamao de la matriz pentadiagonal y N el numer de
ensayos que repetir.

Funcin launch.m:

function [F,T]=launch
% F: flops
% T: tiempo

h = waitbar(0, 'Espera...');
T=[];
N=10;
A=penta(50);
b=crea_b(A);
flops(0);

for i=1:N
tic;
G=chol_(A); %[L,U]=lu_(A)
y=G\b; %y=L\b
x=G'\y; %x=U\y
if i==1
F=flops;
end
T(i)=toc;
waitbar(i/10)
end
close(h);
T=mean(T);
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 12 -
Tabla de los costes de flops y temporal:

flops LU Cholesky
Matlab 16323 flops 48125 flops
0.0010 s 0.0030 s
prcticas 91050 flops 50725 flops
0.2574 s 0.1011 s
optimizado 8477 flops 11558 flops
0.0060 s 0.0500 s
apunte 8574 flops 5934 flops
0.0060 s 0.0060 s

Nota: el error produce con Cholesky o Gaxpy es tal que
( )
t
G G A eps
(con eps=1e-15).




UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 13 -
c) Compara el coste temporal y en flops de los algoritmos modificados con el
coste de los originales, para tamaos de matriz de 16x16 a 128x128 en
incrementos de tamao 16, creadas tambin utilizando la funcion Penta.

Nota: En la presentacin de resultados se debern incluir los listados de los dos algoritmos, as como una
tabla en la que aparezca para cada algoritmo el nmero de flops y el coste temporal del mismo en
cada uno de los casos. Se valorarn especialmente las conclusiones que se extraigan de las
ejecuciones propuestas.

Mtodo directos, costes relativo al tamao

Introduccin:

Construyo un programa efectuando una media del coste temporal. Como precedente,
cada algoritmo para cada tamao sera calculado N veces.

Funcin tabla.m:

function T=tabla
h = waitbar(0,'Espera...');
T=[];
N=5;
Tlu=0; Tlu_=0; Tlup=0; Tlupq=0;
Tch=0; Tch_=0; Tchp=0; Tchgx=0;

for i=16:16:128
A=penta(i);
for j=1:N
flops(0);
tic;
lu(A);
if j==1 Flu=flops; end
Tlu=Tlu+toc/N;

flops(0);
tic;
lu_(A);
if j==1 Flu_=flops; end
Tlu_=Tlu_+toc/N;

flops(0);
lup(A,2);
if j==1 Flup=flops; end
Tlup=Tlup+toc/N;

flops(0);
tic;
lupq(A,2,2);
if j==1 Flupq=flops; end
Tlupq=Tlupq+toc/N;

flops(0);
tic;
chol(A);
if j==1 Fch=flops; end
Tch=Tch+toc/N;

flops(0);
tic;
chol_(A);
if j==1 Fch_=flops; end
Tch_=Tch_+toc/N;
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 14 -
flops(0);
tic;
cholp(A,2);
if j==1 Fchp=flops; end
Tchp=Tchp+toc/N;

flops(0);
tic;
gaxpy(A,2);
if j==1 Fchgx=flops; end
Tchgx=Tchgx+toc/N;

waitbar(i*j/(128*N));
end
T=[T;i Flu Tlu Flu_ Tlu_ Flup Tlup Flupq Tlupq Fch Tch Fch_ Tch_ Fchp
Tchp Fchgx Tchgx];
end
close(h);
save data.txt T -ASCII -double -tabs;
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 15 -
Tablas de los resultados:

LU
Matlab Practicas Optimizado Aparte
n flops seg flops seg flops seg flops seg
16 598 0,000 2992 0,016 489 0,016 518 0,004
32 2478 0,000 22880 0,088 1513 0,090 1574 0,012
48 5638 0,000 76048 0,332 3049 0,338 3142 0,014
64 10078 0,002 178880 0,905 5097 0,915 5222 0,022
80 15798 0,002 347760 2,007 7657 2,025 7814 0,028
96 22798 0,002 599072 3,915 10729 3,942 10918 0,038
112 31078 0,002 949200 7,359 14313 7,395 14534 0,050
128 40638 0,006 1414528 14,451 18409 14,513 18662 0,072

Cholesky
Matlab Practicas Optimizado Aparte
n flops seg flops seg flops seg flops seg
16 1496 0,002 1784 0,006 918 0,004 224 0,000
32 11440 0,002 12528 0,032 2902 0,010 464 0,000
48 38024 0,002 40424 0,124 5910 0,014 704 0,006
64 89440 0,002 93664 0,331 9942 0,024 944 0,006
80 173880 0,002 180440 0,739 14998 0,034 1184 0,010
96 299536 0,004 308944 1,422 21078 0,044 1424 0,020
112 474600 0,006 487368 2,746 28182 0,060 1664 0,038
128 707264 0,010 723904 5,226 36310 0,088 1904 0,058

Grafics:

coste flops (matriz pentadiagonal, n=16,128)
0
20000
40000
60000
80000
100000
120000
140000
16 32 48 64 80 96 112 128
n
flops
Lu_ Lup Chol_ Cholp Gaxpy

coste sec (matriz pentadiagonal, n=16,128)
0,000
0,200
0,400
0,600
0,800
1,000
1,200
1,400
1,600
1,800
2,000
16 32 48 64 80 96 112 128
n
s
Lu_ Lup Chol_ Cholp Gaxpy


Observaciones:

Al nivel del coste en flops encontramos casi los aspectos de los tiempos toricos vistos en
la parte anterior.

Fjese, an que el coste en flops del mtodo LU optimizado es menos que el del mtodo
original, su coste temporal en segundas es casi lo mismo... A lo mejor, son los pasos de
comparaciones en los bucles for en la funcin lup.m. Excepto eso, los costes temporales
siguen bastante bien los aspectos de los costes en flops corespondientes.
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 16 -
Ejercicio 3

Las matrices de Hilbert son un tipo de matrices cuadradas mal condicionadas que se
suelen utilizar como benchmarks para algoritmos de resolucin de sistemas. [ref
Kincaid]. En Matlab podemos obtener la matriz de Hilbert de dimensin n con el
comando hilb(n).

a) Utiliza el algoritmo de descomposicin L-U que has implementado, para
resolver sistemas de ecuaciones que tengan como matriz de coeficientes
matrices de Hilbert (desde hilb(5) a hilb(13) ), y como vector de trminos
independientes el generado por la funcin crea_b, aplicada sobre la matriz
de coeficientes correspondiente.

Nota: Para resolver los sistemas triangulares Ly=b, y Ux=y puedes utilizar el operador \ (ver help slash)
(Ejemplo: Ly=b se resolvera con el comando y=L\b)

Matrices de Hilbert

Introduccin:

El programa siguiente va a construir una matriz H de Hilbert y efectuar Hx b = con x
construido a partir de b y tal que normalmente { } 1, ,1 x = , lo llamaremos I (aqu I es un
vector). La salida ser una tabla dando el nmero de condiciones de la matriz H y
tambin una evaluacin del error obtenido. Por eso, elegiremos el peor error elemento
del vector solucin tal que
( )
max I x

= . Este funcin es norm(I-x,inf) con Matlab.

Funcin test_hilb:

function T=test_hilb
% T: resultados: tamao, cond y error

format short e;
T=[];
for i=5:13
H=hilb(i);
b=crea_b(H);
I=ones(i,1);
[L,U]=lu_(H);
y=L\b;
x=U\y;
T=[T; i cond(H) norm(I-x,inf)]
end
save data.txt T -ASCII -double -tabs;

UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 17 -
b) Calcula el nmero de condicin de cada una de las matrices de Hilbert,
utilizando el comando cond, y relaciona estos datos con la exactitud de las
soluciones de los sistemas que has resuelto, teniendo en cuenta la
informacin del punto 4.2.3 de la unidad temtica 4. Para cuantificar la
exactitud de cada una de las soluciones puedes calcular el error absoluto de
la solucin obtenida, utilizando la norma

, que en Matlab se puede obtener


con el comando norm(x,inf). (Ver help norm).

Nota: En la memoria se deber presentar un resumen tabulado de los datos obtenidos, as como los
comentarios que cada grupo considere pertinentes.

Nmero de condicin

Introduccin:

La funcin precedente da el fichero data.txt contenido los resultados de los nmeros de
condicin.

Tabla recapitulativa:

n cond norma
5 476607,25 2,591E-12
6 14951058,64 4,254E-10
7 475367356,28 1,522E-08
8 15257575253,67 9,222E-07
9 493153214118,79 1,875E-05
10 16025336322027,10 3,012E-04
11 521838915546882,00 2,598E-03
12 17680654104131500,00 8,180E-01
13 3682277791113050000,00 9,681

Observaciones:

La funcin cond() da un nmero de condiciones de la matriz tal que cond(H)=norm(H)*
norm(inv(H)). Eso significa que la matriz de Hilbert tiene una capacidad de invertirse
mal ( incapacidad...), el resultado es directamente ligado al tamao n de H. Al final con
n=13 el vector solucin contenido un elemento 10,3455 es decir con relacin a la solucin
inicial ( sea 1) un error de 968 % !

los valores de cond() siguen una evolucin exponencial respecto al tamao de H.

evolucion cond(H)
1,00E+00
1,00E+02
1,00E+04
1,00E+06
1,00E+08
1,00E+10
1,00E+12
1,00E+14
1,00E+16
1,00E+18
1,00E+20
5 6 7 8 9 10 11 12 13
n
cond




UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 18 -
Ejercicio 4

Una tcnica iterativa para resolver un sistema lineal Ax b = donde A es una matriz de
orden n n , empieza con una aproximacin inicial
( ) 0
x a la solucin x, y genera una
sucesin de vectores
( )
{ }
0
k
k
x
=
de la cual se espera que converja a x. La mayora de
estas tcnicas iterativas involucran un proceso que convierte el sistema Ax b = en un
sistema equivalente de la forma x M x v = + para alguna matriz M de orden n n y un
vector v. Una vez seleccionado el vector inicial
( ) 0
x la sucesin de vectores de solucin
aproximadas se genera calculando:

( ) ( ) 1 k k
x M x v

= + , siendo
1
1
M I C A
v C b



donde A es la matriz de coeficientes y b el trmino independiente. Segn la eleccin de la
matriz C se obtiene un mtodo iterativo particular.

a) Implementa el algoritmo de Gauss-Seidel en forma escalar que se describe a
continuacin.

Mtodos iterativos, generalidades

Entradas/salidas mtodos iterativos:

Para cada mtodo iterativo, tendrmos siempre como parmetros de entradas:
- La matriz de coeficientes
( )
{ }
,
, 0 1, ,
n n
i i
A A i n

=
- El vector de trminos independientes
n
b
- La solucin inicial 0
n
x
- La tolerancia tol
- El nmero mximo de iteraciones iter.

Y como parmetros de salidas:
- La solucin x
- El valor del error err
- El valor de iter

Criterio de parada:

Como criterio de parada de los algoritmos, utilic el error absoluto, sea
( ) ( ) 1 k k
x x
+

= .
Pero, para facilitar lo que seguir, vamos a crear una funcin para todos los algoritmos
iterativos. As, en la parte siguiente, elegiremos el criterio de parada cambiando esta
funcin construda con el mando switch.
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 19 -
Funcin criterr.m:

function err=criterr(x,x0,metodo)
% criterio de error

switch metodo
case 'absoluto', err=norm(x-x0,inf);
case 'relativo', err=norm(x-x0,inf)/norm(x,inf);
otherwise err=norm(x-x0);
end

Mtodo de Gauss-Seidel (nivel escalar)

funcin Gseidel_s:

function [x,err,k]=Gseidel_s(A,b,x0,tol,iter)
% Mtodo iterativo, Gauss-Seidel escalar
% A: Matriz de coeficientes
% b: Vector de terminos
% x0: solucion inicial
% tol: tolerancia
% iter: numero de iteraciones

[n,m]=size(A);
if n~=m error('Matriz no cuadrada.'); end

k=0;
condi=0;
while (condi==0 & k<iter)
for i=1:n
if A(i,i)==0 error('A(i,i)=0'); end
aux=0;
for j=1:i-1
aux=aux+A(i,j)*x(j);
end
for j=i+1:n
aux=aux+A(i,j)*x0(j);
end
x(i)=(b(i)-aux)/A(i,i);
end
err=criterr(x,x0,'absoluto');
if err<tol condi=1;
else
k=k+1;
x0=x;
end
end
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 20 -
Mtodo de Jacobi (nivel escalar)

Funcin Jacobi_s.m:

function [x,err,k]=Jacobi_s(A,b,x0,tol,iter)
% Mtodo iterativo, Jacobi escalar
% A: Matriz de coeficientes
% b: Vector de terminos
% x0: solucion inicial
% tol: tolerancia
% iter: numero de iteraciones

[n,m]=size(A);
if n~=m error('Matriz no cuadrada.'); end

k=0;
condi=0;
while (condi==0 & k<iter)
for i=1:n
if A(i,i)==0 error('A(i,i)=0'); end
aux=0;
for j=1:i-1
aux=aux+A(i,j)*x0(j);
end
for j=i+1:n
aux=aux+A(i,j)*x0(j);
end
x(i)=(b(i)-aux)/A(i,i);
end
err=criterr(x,x0,'absoluto');
if err<tol condi=1;
else
k=k+1;
x0=x;
end
end


UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 21 -
b) Implementa el algoritmo de Gauss-Seidel en forma matricial, dado a
continuacin.

Mtodo de Gauss-Seidel (nivel matricial)

funcin Gseidel_M:

function [x,err,k]=Gseidel_M(A,b,x0,tol,iter)
% Mtodo iterativo, Gauss-Seidel matricial
% A: Matriz de coeficientes
% b: Vector de terminos
% x0: solucion inicial
% tol: tolerancia
% iter: numero de iteraciones

[n,m]=size(A);
if n~=m error('Matriz no cuadrada.'); end

k=0;
condi=0;
while (condi==0 & k<iter)
aux=-(triu(A,1))*x0+b;
x=tril(A)\aux;
err=criterr(x,x0,'absoluto');
if err<tol condi=1;
else
k=k+1;
x0=x;
end
end

Mtodo de Jacobi (nivel matricial)

function [x,err,k]=Jacobi_M(A,b,x0,tol,iter)
% Mtodo iterativo, Jacobi matricial
% A: Matriz de coeficientes
% b: Vector de terminos
% x0: solucion inicial
% tol: tolerancia
% iter: numero de iteraciones

[n,m]=size(A);
if n~=m error('Matriz no cuadrada.'); end

k=0;
condi=0;
while (condi==0 & k<iter)
D=diag(diag(A));
aux=-(A-D)*x0+b;
x=D\aux;
err=criterr(x,x0,'absoluto');
if err<tol condi=1;
else
k=k+1;
x0=x;
end
end



UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 22 -
c) Compara el coste temporal y el nmero de flops de los algoritmos, para
tamaos de la matriz de coeficientes variando desde 16x16 hasta 128x128, en
incrementos de tamao 16. Para ello crea los sistemas utilizando las
funciones diagdomi y crea_b.

Nota: En la memoria se debern incluir los listados de los algoritmos, as como una tabla con los
resultados obtenidos, que deber incluir los valores calculados de nmero de iteraciones, tiempo,
nmero de flops y error relativo, para cada uno de los algoritmos en cada uno de los casos. El error
relativo se deber calcular de la siguiente manera:

( ) ( )
( )
1 k k
k
x x
x
+



Mtodos iterativos, costes relativo al tamao

Introduccin:

El programa que se construir ser casi lo mismo que el precedente. Adems como antes,
para cada algoritmo y cada tamao sera calculado N ensayos.

En este parte, cogeremos los parmetros de entrada siguientes:

- tol=1e-4
- iter=50
- x(0)={2,...,2}.
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 23 -
Funcin tabla_.m:

function T=tabla_

format short e;
h=waitbar(0,'Espera...');

T=[];
N=3;
FGs=0; TGs=0; FGM=0; TGM=0; FJs=0; TJs=0; FJM=0; TJM=0;
EGs=0; kGs=0; EGM=0; kGM=0; EJs=0; kJs=0; EJM=0; kJM=0;

tol=1e-4;
iter=50;

for i=16:16:128
A=diagdomi(i);
b=crea_b(A);
x0=ones(i,1)+1;

for j=1:N
flops(0);
tic;
[x,EGs,kGs]=Gseidel_s(A,b,x0',tol,iter);
if j==1 FGs=flops; end
TGs=TGs+toc/N;

flops(0);
tic;
[x,EGM,kGM]=Gseidel_M(A,b,x0,tol,iter);
if j==1 FGM=flops; end
TGM=TGM+toc/N;

flops(0);
tic;
[x,EJs,kJs]=Jacobi_s(A,b,x0',tol,iter);
if j==1 FJs=flops; end
TJs=TJs+toc/N;

flops(0);
tic;
[x,EJM,kJM]=Jacobi_M(A,b,x0,tol,iter);
if j==1 FJM=flops; end
TJM=TJM+toc/N;

waitbar(i*j/(128*N));
end
T=[T;i FGs TGs EGs kGs FGM TGM EGM kGM
FJs TJs EJs kJs FJM TJM EJM kJM];
end
close(h);
save data.txt T -ASCII -double -tabs;
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 24 -
Tablas de los resultados:

Gauss-Seidel
escalar matricial
n flops sec error iter flops sec error iter
16 3933 0,0200 4,88E-05 6 5837 0,0000 4,88E-05 6
32 15021 0,0767 5,13E-05 6 22413 0,0000 5,13E-05 6
48 33277 0,1800 5,24E-05 6 49741 0,0067 5,24E-05 6
64 58701 0,3600 5,30E-05 6 87821 0,0133 5,30E-05 6
80 91293 0,6237 5,33E-05 6 136653 0,0367 5,33E-05 6
96 131053 1,0543 5,36E-05 6 196237 0,0533 5,36E-05 6
112 177981 1,6053 5,38E-05 6 266573 0,0800 5,38E-05 6
128 232077 2,3463 5,39E-05 6 347661 0,1367 5,39E-05 6

Jacobi
escalar matricial
n flops sec error iter flops sec error iter
16 12925 0,0503 9,80E-05 22 25069 0,0033 9,80E-05 22
32 55795 0,2373 8,08E-05 25 109875 0,0067 8,08E-05 25
48 128357 0,6443 8,01E-05 26 254069 0,0303 8,01E-05 26
64 226421 1,3753 9,78E-05 26 449333 0,0707 9,78E-05 26
80 365175 2,4870 7,51E-05 27 725815 0,1407 7,51E-05 27
96 524215 4,6670 8,15E-05 27 1042999 0,2473 8,15E-05 27
112 711927 6,8033 8,65E-05 27 1417527 0,3907 8,65E-05 27
128 928311 9,7207 9,04E-05 27 1849399 0,6247 9,04E-05 27

Grafics:


coste flops (err=1e-4, n=16,128)
0,E+00
2,E+05
4,E+05
6,E+05
8,E+05
1,E+06
1,E+06
1,E+06
2,E+06
2,E+06
2,E+06
16 32 48 64 80 96 112 128
n
flops
Gauss escalar Gauss matricial
Jacobi escalar Jacobi matricial

coste temporal (err=1e-4, n=16,128)
0
1
2
3
4
5
6
7
8
9
10
11
16 32 48 64 80 96 112 128
n
s
Gauss escalar Gauss matricial
Jacobi escalar Jacobi matricial


Observaciones:

La teora se verifica muy bien. Se nota que los mtodos iterativos a nivel matricial son
muy eficientes con relacin a los a nivel escalar. Adems, an que el coste en flops sea
importante (se nota bien con Jacobi matricial por ejemplo), su coste temporal es mucho
mejor que los mtodos escalares. Al final, encontramos bien las relaciones entre estos
mtodos. Es decir lo que hemos visto en la parte terica, hablando de la potencia de estos
mtodos, y con la condicin de convergencia, tenemos:

Gauss-Seidel Matricial > Jacobi Matricial > Gauss-Seidel escalar > Jacobi escalar
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 25 -
Ejercicio 5

a) Averigua para qu tamao de un sistema comienza a ser ms adecuado el
uso de un mtodo iterativo en comparacin con un mtodo directo. Para ello
resuelve los sistemas de ecuaciones generados en el ejercicio 4 utilizando el
algoritmo de resolucin de sistemas que implementaste en el Ejercicio 3, y
calcula el coste temporal y en flops.


Comparacion costes mtodos directos y iterativos

Introduccin:

El programa siguiente es lo mismo que los precedentes. Genera una tabla T en el fichero
data.txt, contenido los resultados.

funcin comp.m:

function comp;
% comparacin costes flops
% mtodos diretos o iterativos
% ti: tamao inicial
% tf: tamao final

format short e;
h = waitbar(0,'Espera...');

ti=1;
tf=50;
N=3;

tol=1e-6;
iter=500;

T=[];
Flu_=0; Tlu_=0; Fch_=0; Tch_=0;
FGs=0; TGs=0; FGM=0; TGM=0;
FJs=0; TJs=0; FJM=0; TJM=0;

for i=ti:tf
for j=1:N
A=diagdomi(i);
b=crea_b(A);
x0=zeros(i,1);

flops(0);
tic;
[L,U]=lu_(A);
y=L\b;
x=U\y;
if j==1 Flu_=flops; end
Tlu_=Tlu_+toc/N;

flops(0);
tic;
G=chol_(A);
y=G\b;
x=G'\y;
if j==1 Fch_=flops; end
Tch_=Tch_+toc/N;
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 26 -
flops(0);
tic;
G=Gseidel_s(A,b,x0',tol,iter);
if j==1 FGs=flops; end
TGs=TGs+toc/N;

flops(0);
tic;
G=Jacobi_s(A,b,x0',tol,iter);
if j==1 FJs=flops; end
TJs=TJs+toc/N;

flops(0);
tic;
G=Gseidel_M(A,b,x0,tol,iter);
if j==1 FGM=flops; end
TGM=TGM+toc/N;

flops(0);
tic;
G=Jacobi_M(A,b,x0,tol,iter);
if j==1 FJM=flops; end
TJM=TJM+toc/N;

waitbar(i*j/((tf-ti)*N),h)
end
T=[T;i Flu_ Tlu_ Fch_ Tch_ FGs TGs FJs TJs FGM TGM FJM TJM];
end
close(h);
save data.txt T -ASCII -DOUBLE -tabs;
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 27 -

Tabla recapitulativa:

Directos Iterativos escalar Iterativos Matricial
Lu Chol Gauss Seidel Jacobi Gauss Seidel Jacobi
n flops seg flops seg flops seg flops seg flops seg flops seg
1 4 0,000 6 0,000 13 0,000 13 0,000 11 0,000 13 0,000
2 26 0,000 29 0,000 127 0,000 207 0,003 175 0,007 337 0,000
3 58 0,000 59 0,000 231 0,003 492 0,010 327 0,007 849 0,000
4 108 0,000 102 0,000 367 0,003 965 0,020 527 0,007 1721 0,003
5 180 0,000 160 0,000 602 0,010 1540 0,027 872 0,007 2805 0,007
6 278 0,000 235 0,000 827 0,017 2299 0,037 1205 0,007 4249 0,013
7 406 0,000 329 0,007 1088 0,020 3266 0,057 1592 0,007 6101 0,013
8 568 0,003 444 0,010 1385 0,020 4311 0,084 2033 0,007 8119 0,013
9 768 0,010 582 0,010 1718 0,027 5538 0,110 2528 0,007 10497 0,020
10 1010 0,013 745 0,017 2087 0,033 6959 0,140 3077 0,007 13259 0,023
11 1298 0,017 935 0,020 2492 0,040 8586 0,174 3680 0,007 16429 0,033
12 1636 0,023 1154 0,027 2933 0,050 10105 0,207 4337 0,010 19405 0,037
13 2028 0,033 1404 0,030 3410 0,067 12127 0,250 5048 0,010 23359 0,037
14 2478 0,040 1687 0,040 3923 0,084 14387 0,301 5813 0,010 27785 0,047
15 2990 0,050 2005 0,043 4472 0,104 16400 0,364 6632 0,010 31745 0,050
16 3568 0,063 2360 0,053 5057 0,124 19107 0,431 7505 0,010 37059 0,057
17 4216 0,087 2754 0,060 5678 0,147 21453 0,501 8432 0,010 41683 0,070
18 4938 0,107 3189 0,067 6335 0,177 23935 0,571 9413 0,010 46579 0,084
19 5738 0,130 3667 0,083 7028 0,200 27334 0,664 10448 0,010 53269 0,084
20 6620 0,164 4190 0,090 7757 0,227 30169 0,764 11537 0,010 58869 0,090
21 7588 0,194 4760 0,110 8522 0,254 33144 0,877 12680 0,013 64749 0,097
22 8646 0,230 5379 0,127 9323 0,284 36259 1,001 13877 0,023 70909 0,104
23 9798 0,274 6049 0,147 10160 0,318 40643 1,134 15128 0,023 79559 0,104
24 11048 0,320 6772 0,164 11033 0,361 44135 1,281 16433 0,023 86471 0,107
25 12400 0,380 7550 0,184 11942 0,401 47771 1,445 17792 0,023 93671 0,117
26 13858 0,441 8385 0,204 12887 0,448 51551 1,612 19205 0,027 101159 0,124
27 15426 0,507 9279 0,234 13868 0,494 55475 1,785 20672 0,027 108935 0,134
28 17108 0,584 10234 0,261 14885 0,541 61197 1,985 22193 0,027 120249 0,141
29 18908 0,668 11252 0,294 15938 0,584 65526 2,199 23768 0,027 128833 0,147
30 20830 0,761 12335 0,334 17027 0,641 70003 2,429 25397 0,030 137713 0,154
31 22878 0,864 13485 0,384 18152 0,695 74628 2,676 27080 0,037 146889 0,161
32 25056 1,138 14704 0,491 19313 0,875 79401 3,330 28817 0,040 156361 0,191
33 27368 1,442 15994 0,621 20510 1,058 84322 4,071 30608 0,043 166129 0,217
34 29818 1,770 17357 0,761 21743 1,248 89391 4,796 32453 0,053 176193 0,254
35 32410 2,144 18795 0,915 23012 1,435 97165 5,630 34352 0,053 191595 0,287
36 35148 2,555 20310 1,095 24317 1,656 102675 6,508 36305 0,053 202539 0,314
37 38036 3,019 21904 1,272 25658 1,859 108337 7,453 38312 0,057 213787 0,361
38 41078 3,493 23579 1,476 27035 2,086 114151 8,411 40373 0,060 225339 0,394
39 44278 3,980 25337 1,702 28448 2,341 120117 9,392 42488 0,063 237195 0,427
40 47640 4,548 27180 1,912 29897 2,595 126235 10,433 44657 0,070 249355 0,474
41 51168 5,176 29110 2,136 31382 2,858 132505 11,618 46880 0,073 261819 0,517
42 54866 5,817 31129 2,383 32903 3,132 138927 12,777 49157 0,077 274587 0,551
43 58738 6,498 33239 2,660 34460 3,402 145501 13,985 51488 0,080 287659 0,597
44 62788 7,269 35442 2,947 36053 3,693 152227 15,277 53873 0,087 301035 0,657
45 67020 8,083 37740 3,257 37682 4,020 159105 16,553 56312 0,100 314715 0,711
46 71438 8,958 40135 3,561 39347 4,344 166135 17,894 58805 0,117 328699 0,757
47 76046 9,866 42629 3,905 41048 4,704 177878 19,350 61352 0,117 352013 0,824
48 80848 10,811 45224 4,272 42785 5,058 185405 20,888 63953 0,124 366989 0,871
49 85848 11,818 47922 4,667 44558 5,412 193088 22,450 66608 0,137 382277 0,941
50 91050 12,899 50725 5,064 46367 5,802 200927 24,043 69317 0,144 397877 0,985
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 28 -
Grafico comparativo del coste en flops:

comparacion coste flops (e=1e-6)
0,00
2000,00
4000,00
6000,00
8000,00
10000,00
12000,00
14000,00
n 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
n
flops
Directos Lu
Directos Cholesky
Iterativos escalar Gauss Seidel
Iterativos escalar Jacobi
Iterativos Matricial Gauss Seidel
Iterativos Matricial Jacobi


Grafico comparativo del coste temporal:

comparacion coste temporal (e=1e-6)
0,00
0,05
0,10
0,15
0,20
0,25
0,30
0,35
0,40
n 1 2 3 4 5 6 7 8 9 1011121314151617181920212223242526272829303132333435363738394041424344454647484950
n
seg
Directos Lu
Directos Chol
Iterativos escalar Gauss Seidel
Iterativos escalar Jacobi
Iterativos Matricial Gauss Seidel
Iterativos Matricial Jacobi

UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 29 -
Grfico comparativo del nivel de potencia:

En este grfico, representamos un nivel de potencia tal que:

( )
seg
t
y x
flops
=

(es decir el tiempo necesitado para una operacin)

Eso permite la comparacin con el coste temporal y el coste en flops conjuntos. El
principio de este anlisis no permite una contestacin con el tema de un mtodo
especfico. Pero a partir de n=10, los costes (sobre todo temporal) se estabilizan.

As, los mtodos baratos en tiempo a pesar de sus nmeros de flops (el menos
significativo para Matlab) se notan. Los mtodos matriciales, Jacobi o Gauss-Seidel, son
muy eficientes porque su nivel de potencia se va hacia cero, es decir un conjunto de tipo:

0
seg
t
flops




Los otros mtodos se parcen muy parejos, a partir de n=30, se nota un cambio de aspecto.

comparacion coste temporal (e=1e-6)
0,00E+00
2,00E-05
4,00E-05
6,00E-05
8,00E-05
1,00E-04
1,20E-04
1,40E-04
n 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
n
seg/flops
Directos Lu
Directos Cholesky
Iterativos escalar Gauss Seidel
Iterativos escalar Jacobi
Iterativos matricial Gauss Seidel
Iterativos matricial Jacobi

UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 30 -
b) Compara estos costes con los que has obtenido utilizando los mtodos de
Gauss-Seidel a nivel escalar y matricial (Ejercicio 4) e indica a partir de qu
dimensin de las matrices comienzan a ser ms eficientes cada uno de estos
mtodos.

Nota: Se deber incluir una tabla con los resultados para cada uno de los algoritmos variando el tamao
de la matriz (tiempo y nmero de flops), junto con una explicacin de los resultados obtenidos y las
representaciones grficas que se necesiten.

Detecin de la potencia del coste temporal

Introduccin:

Para comparar los costes temporales de los mtodos directos y iterativos al nivel de las
dimensiones de las matrices entradas, construmos un programa comparando el coste en
segundos entre un mtodo de LU y un de Jacobi Matricial. Lo haremos despus con
Cholesky a plaza de LU. El principio es aumentar la dimensin de las matrices y
comparar el coste temporal (estadistico, con N ensayos).

Por supuesto la salida sera i tal que
directo iterativo
t t > , este programa supone que sepamos
que al inicio
directo iterativo
t t < .

Por fin, el resultado que saldr de este programa no es un valor fijado, porque el coste de
un mtodo iterativo es funcin del nivel de precisin y de la solucin inicial. Por eso,
como precedemente, eligiremos una solucin inicial nula y un nivel de precisin de 1E-6.

Nota: El coste temporal es ms significativo que el coste en flops para la eleccin de un mtodo de
resolucin de sistemas de ecuaciones lineales. Adems Matlab esta optimizado para operaciones
matriciales (MATrix LABoratory...)..

funcin comp_.m:

function i=comp_;
% comparacin costes toc/N
% mtodos diretos o iterativos

format short e;
h=waitbar(0,'Espera...');

tol=1e-6; iter=500;
i=1; imax=50; N=20;
Td=0; Ti=0;

while (Td<=Ti & i<imax)
for j=1:N
A=diagdomi(i);
b=crea_b(A);
x0=zeros(i,1);

tic;
[L,U]=lu_(A); % G=chol_(A);
y=L\b; % y=G\b;
x=U\y; % x=G'\y;
Td=Td+toc/N;
UPV - Computacin de Altas Prestaciones - Prcticas 1 David Perrin

- 31 -
tic;
G=Jacobi_M(A,b,x0,tol,iter);
Ti=Ti+toc/N;
end
i=i+1;
waitbar(i*j/(imax*N))
end
close(h);

Resultados:

El mando >>comp_ da los resultados siguientes

LU Cholesky
Jacobi Matricial n=16 n=22

Nota: O sea,
( ) LU Jacobi M
t t > para n=16 y
( ) Cholesky Jacobi M
t t > para n=22. Estos resultados se notan muy
bien con el grfico de los costes temporales precedentes. Es decir con el grfico siguiente:

comparacion coste temporal (e=1e-6)
0,00
0,02
0,04
0,06
0,08
0,10
0,12
0,14
n 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
n
seg
Directos Lu Directos Cholesky Iterativos Matricial Jacobi
tjacobi>tLU
tjacobi>tCholesky


Observaciones:

Es muy dificil de concluir sobre el tema del mejor mtodo para la resolucin de sistems
de ecuaciones lineales. En verdad, esta comparacin depende del ordenador utilizado
pero sobre todo del nivel de tolerancia pedido y de la solucin inicial.

Nota: Todos los ensayos han sido efectuados en un portatil Duron

1200 MHz y 128 Mo de ram.