Métodos Numéricos

Tema 6: Métodos iterativos para sistemas de ecuaciones

Dep. Matmática Aplicada III
EPSEM-UPC
Profesor: Francisco Palacios
Abril 2008, Versión 1.3
>
Ejercicio 1
El siguiente programa calcula el valor de de las cuatro primeras iteraciones xx1,xx2,xx3,xx4 y los errores estimados
erb1,erb2,erb3,erb4.
Usamos vectores para representar matrices columna. Esto nos permite ahorrar espacio en la presentación de resultados.
Maple trata los vectores como matrices columna en los productos por matriz.
> restart;
with(linalg):
A:=matrix(2,2,[2,5,10,-1]);
b:=[12,8];
N:=matrix(2,2,[0,5,10,0]);
P:=evalm(N-A);
N1:=inverse(N);
M:=evalm(N1&*P);
c:=evalm(N1&*b);
`*******conversión float *****`;
M:=evalf(evalm(M));
c:=evalf(evalm(c));
`****** método iterativo ******`;
xx.0:=[0,0];
n:=3;
for i from 0 to n do
`************ iteracion `,i+1,`************`;
xx.(i+1):=evalm(M&*(xx.i)+c);
erb.(i+1):=evalm(xx.(i+1)-xx.i);# vector de error estimado
nerb.(i+1):=norm(erb.(i+1),infinity);
od;
>
Warning, new definition for norm
Warning, new definition for trace
⎡ 2 5⎤
A := ⎢ ⎥
⎣10 -1⎦
b := [ 12, 8 ]
⎡ 0 5⎤
N := ⎢ ⎥
⎣10 0⎦
⎡ -2 0⎤
P := ⎢ ⎥
⎣ 0 1⎦
⎡ 1 ⎤
⎢ 0 ⎥
⎢ 10 ⎥⎥
N1 := ⎢⎢ ⎥
⎢ 1 0 ⎥⎥
⎢
⎣ 5 ⎦
⎡ 1 ⎤
⎢ 0 ⎥
⎢ 10 ⎥⎥
M := ⎢⎢ ⎥
⎢ -2 0 ⎥⎥
⎢
⎣ 5 ⎦
⎡ 4 12 ⎤
c := ⎢⎢ , ⎥⎥
⎣5 5 ⎦
*******conversión float *****
⎡ 0 .1000000000⎤
M := ⎢ ⎥
⎣-.4000000000 0 ⎦
c := [ .8000000000, 2.400000000 ]
****** método iterativo ******
xx0 := [ 0, 0 ]
Page 1
 n := 3
************ iteracion , 1, ************
xx1 := [ .8000000000, 2.400000000 ]
erb1 := [ .8000000000, 2.400000000 ]
nerb1 := 2.400000000
************ iteracion , 2, ************
xx2 := [ 1.040000000, 2.080000000 ]
erb2 := [ .2400000000, -.320000000 ]
nerb2 := .320000000
************ iteracion , 3, ************
xx3 := [ 1.008000000, 1.984000000 ]
erb3 := [ -.032000000, -.096000000 ]
nerb3 := .096000000
************ iteracion , 4, ************
xx4 := [ .9984000000, 1.996800000 ]
erb4 := [ -.0096000000, .012800000 ]
nerb4 := .012800000
Cota de error usando la acotación en 4 pasos.
> nm:=norm(M,infinity);
ce4:=nm^4/(1-nm)*nerb1;
nm := .4000000000
ce4 := .1024000000
Cota de error usando la acotación en un paso.
> ce4:=nm/(1-nm)*nerb4;
ce4 := .008533333334
Valor y error exacto.
> s:=linsolve(A,b);
er4:=evalm(xx4-s);
ner4:=norm(er4,infinity);
s := [ 1, 2 ]
er4 := [ -.0016000000, -.003200000 ]
ner4 := .003200000
Ejercicio 2
Valor de las cuatro primeras iteraciones usando el método de Jacobi.
> restart;
with(linalg):
A:=matrix(2,2,[20,2,1,-10]);
b:=[14,31];
N:=matrix(2,2,[A[1,1],0,0,A[2,2]]);#Matriz de iteración para el método de Jacobi
P:=evalm(N-A);
N1:=inverse(N);
M:=evalm(N1&*P);
c:=evalm(N1&*b);
`*******conversión float *****`;
M:=evalf(evalm(M));
c:=evalf(evalm(c));
`****** método iterativo ******`;
xx.0:=[0,0];
n:=3;
for i from 0 to n do
`************* iteración `,i+1,`************`;
xx.(i+1):=evalm(M&*(xx.i)+c);
erb.(i+1):=evalm(xx.(i+1)-xx.i);
nerb.(i+1):=norm(erb.(i+1),infinity);
od;

Warning, new definition for norm

Warning, new definition for trace
Page 2
 ⎡20 2⎤
A := ⎢ ⎥
⎣ 1 -10⎦
b := [ 14, 31 ]
⎡20 0⎤
N := ⎢ ⎥
⎣ 0 -10⎦
⎡0 -2⎤
P := ⎢ ⎥
⎣-1 0⎦
⎡ 1 ⎤
⎢ 0 ⎥⎥
⎢ 20
N1 := ⎢⎢ ⎥
⎢ 0 -1 ⎥⎥
⎢ ⎥
⎣ 10 ⎦
⎡ -1 ⎤
⎢ 0 ⎥
⎢ 10 ⎥⎥
M := ⎢⎢ ⎥
⎢ 1 0 ⎥⎥
⎢
⎣ 10 ⎦
⎡ 7 -31 ⎤
c := ⎢⎢ , ⎥⎥
⎣ 10 10 ⎦
*******conversión float *****
⎡ 0 -.1000000000⎤
M := ⎢ ⎥
⎣.1000000000 0 ⎦
c := [ .7000000000, -3.100000000 ]
****** método iterativo ******
xx0 := [ 0, 0 ]
n := 3
************* iteración , 1, ************
xx1 := [ .7000000000, -3.100000000 ]
erb1 := [ .7000000000, -3.100000000 ]
nerb1 := 3.100000000
************* iteración , 2, ************
xx2 := [ 1.010000000, -3.030000000 ]
erb2 := [ .3100000000, .070000000 ]
nerb2 := .3100000000
************* iteración , 3, ************
xx3 := [ 1.003000000, -2.999000000 ]
erb3 := [ -.007000000, .031000000 ]
nerb3 := .031000000
************* iteración , 4, ************
xx4 := [ .9999000000, -2.999700000 ]
erb4 := [ -.0031000000, -.000700000 ]
nerb4 := .0031000000
Cota de error usando la acotación en 4 pasos.
> nm:=norm(M,infinity);
ce4:=nm^4/(1-nm)*nerb1;
nm := .1000000000
ce4 := .0003444444444
Cota de error usando la acotación en un paso.
> ce4:=nm/(1-nm)*nerb4;
ce4 := .0003444444444
Valor y error exacto.
> s:=linsolve(A,b);
er4:=evalm(xx4-s);
ner4:=norm(er4,infinity);
s := [ 1, -3 ]
er4 := [ -.0001000000, .000300000 ]
ner4 :=Page 3
.000300000
>
Ejercicio 3

Valor de las cuatro primeras iteraciones usando el método de Gauss-Seidel.

> restart;
with(linalg):
A:=matrix(2,2,[20,2,1,-10]);
b:=[14,31];
N:=matrix(2,2,[A[1,1],0,A[2,1],A[2,2]]);#Matriz de iteración para el método de
Gauss-Seidel
P:=evalm(N-A);
N1:=inverse(N);
M:=evalm(N1&*P);
c:=evalm(N1&*b);
`*******conversión float *****`;
M:=evalf(evalm(M));
c:=evalf(evalm(c));
`****** método iterativo ******`;
xx.0:=[0,0];
n:=3;
for i from 0 to n do
`************* iteración `,i+1,`************`;
xx.(i+1):=evalm(M&*(xx.i)+c);
erb.(i+1):=evalm(xx.(i+1)-xx.i);
nerb.(i+1):=norm(erb.(i+1),infinity);
od;

Warning, new definition for norm

Warning, new definition for trace
⎡20 2⎤
A := ⎢ ⎥
⎣ 1 -10⎦
b := [ 14, 31 ]
⎡20 0⎤
N := ⎢ ⎥
⎣ 1 -10⎦
⎡0 -2⎤
P := ⎢ ⎥
⎣0 0⎦
⎡ 1 ⎤
⎢ 0 ⎥⎥
⎢ 20
N1 := ⎢⎢ ⎥
⎢ 1 -1 ⎥⎥
⎢ ⎥
⎣ 200 10 ⎦
⎡ -1 ⎤
⎢ 0 ⎥
⎢ 10 ⎥⎥
M := ⎢⎢
⎢ -1 ⎥⎥
⎢ 0 ⎥
⎣ 100 ⎦
⎡ 7 -303 ⎤
c := ⎢⎢ , ⎥⎥
⎣ 10 100 ⎦
*******conversión float *****
⎡0 -.1000000000 ⎤
M := ⎢ ⎥
⎣0 -.01000000000⎦
c := [ .7000000000, -3.030000000 ]
****** método iterativo ******
xx0 := [ 0, 0 ]
n := 3
************* iteración , 1, ************
xx1 := [ .7000000000, -3.030000000 ]
erb1 := [ .7000000000, -3.030000000 ]
nerb1 := 3.030000000
************* iteración , 2, ************
Page 4
 xx2 := [ 1.003000000, -2.999700000 ]
erb2 := [ .3030000000, .030300000 ]
nerb2 := .3030000000
************* iteración , 3, ************
xx3 := [ .9999700000, -3.000003000 ]
erb3 := [ -.0030300000, -.000303000 ]
nerb3 := .0030300000
************* iteración , 4, ************
xx4 := [ 1.000000300, -2.999999970 ]
erb4 := [ .0000303000, .3030 10-5 ]
nerb4 := .0000303000
Cota de error usando la acotación en 4 pasos.
> nm:=norm(M,infinity);
ce4:=nm^4/(1-nm)*nerb1;
nm := .1000000000
ce4 := .0003366666666
Cota de error usando la acotación en un paso.
> ce4:=nm/(1-nm)*nerb4;
ce4 := .3366666666 10-5
Valor y error exacto.
> s:=linsolve(A,b);
er4:=evalm(xx4-s);
ner4:=norm(er4,infinity);
s := [ 1, -3 ]
er4 := [ .300 10-6, .30 10-7 ]
ner4 := .300 10-6

Problema 4.
Primeras 3 iteraciones del método de Jacobi.

> restart;
with(linalg):
A:=matrix(3,3,[8,1,0,2,5,0,1,0,4]);
b:=[4,3,3];
N:=matrix(3,3,[8,0,0,0,5,0,0,0,4]);
P:=evalm(N-A);
N1:=inverse(N);
M:=evalm(N1&*P);
c:=evalm(N1&*b);
`*******conversión float *****`;
M:=evalf(evalm(M));
c:=evalf(evalm(c));
`****** método iterativo ******`;
xx.0:=[0,0,0];
n:=2;
for i from 0 to n do
`************* iteración `,i+1,`************`;
xx.(i+1):=evalm(M&*(xx.i)+c);
erb.(i+1):=evalm(xx.(i+1)-xx.i);
nerb.(i+1):=norm(erb.(i+1),infinity);
od;

Warning, new definition for norm

Warning, new definition for trace
⎡8 1 0⎤
⎢ ⎥
A := ⎢ 2 5 0⎥
⎢ ⎥
⎣1 0 4⎦
b := [ 4, 3, 3 ]
Page 5
 ⎡8 0 0⎤
⎢ ⎥
N := ⎢ 0 5 0⎥
⎢ ⎥
⎣0 0 4⎦
⎡0 -1 0⎤
⎢ ⎥
P := ⎢-2 0 0⎥
⎢ ⎥
⎣-1 0 0⎦
⎡ 1 ⎤
⎢ 0 0 ⎥⎥
⎢ 8
⎢ ⎥
⎢ 1 ⎥
N1 := ⎢⎢ 0 0 ⎥⎥
⎢ 5 ⎥
⎢ ⎥
⎢ 1 ⎥
⎢⎢ 0 0 ⎥⎥
⎣ 4 ⎦
⎡ -1 ⎤
⎢ 0 0⎥⎥
⎢ 8
⎢ ⎥
⎢ -2 ⎥
M := ⎢⎢ 0 0⎥⎥
⎢ 5 ⎥
⎢ ⎥
⎢ -1 ⎥
⎢⎢ 0 0⎥⎥
⎣ 4 ⎦
⎡1 3 3⎤
c := ⎢⎢ , , ⎥⎥
⎣2 5 4⎦
*******conversión float *****
⎡ 0 -.1250000000 0⎤
⎢ ⎥
M := ⎢-.4000000000 0 0⎥
⎢ ⎥
⎣-.2500000000 0 0⎦
c := [ .5000000000, .6000000000, .7500000000 ]
****** método iterativo ******
xx0 := [ 0, 0, 0 ]
n := 2
************* iteración , 1, ************
xx1 := [ .5000000000, .6000000000, .7500000000 ]
erb1 := [ .5000000000, .6000000000, .7500000000 ]
nerb1 := .7500000000
************* iteración , 2, ************
xx2 := [ .4250000000, .4000000000, .6250000000 ]
erb2 := [ -.0750000000, -.2000000000, -.1250000000 ]
nerb2 := .2000000000
************* iteración , 3, ************
xx3 := [ .4500000000, .4300000000, .6437500000 ]
erb3 := [ .0250000000, .0300000000, .0187500000 ]
nerb3 := .0300000000
Cota de error usando la acotación en 3 pasos.
> nm:=norm(M,infinity);
ce3:=nm^3/(1-nm)*nerb1;
nm := .4000000000
ce3 := .08000000003
Cota de error usando la acotación en un paso.
> ce3:=nm/(1-nm)*nerb3;
ce3 := .02000000000
Valor y error exacto.
> s:=linsolve(A,b);
er3:=evalm(xx3-s);
ner3:=norm(er3,infinity);
⎡ 17 8 97 ⎤
s := ⎢⎢ , , ⎥⎥
⎣ 38 19 152 ⎦
er3 := [ .0026315789, .0089473684, .0055921053 ]
Page 6
 ner3 := .0089473684
>
Problema 5.
Solución exacta.
> restart;
with(linalg):
A:=matrix(3,3,[8,1,0,2,5,0,1,0,4]);
b:=[4,3,3];
s:=linsolve(A,b);
sf:=evalf(evalm(s));
Warning, new definition for norm
Warning, new definition for trace
⎡8 1 0⎤
⎢ ⎥
A := ⎢ 2 5 0⎥
⎢ ⎥
⎣1 0 4⎦
b := [ 4, 3, 3 ]
⎡ 17 8 97 ⎤
s := ⎢⎢ , , ⎥⎥
⎣ 38 19 152 ⎦
sf := [ .4473684211, .4210526316, .6381578947 ]
Matriz M para el método de Jacobi
> N:=matrix(3,3,[A[1,1],0,0,0,A[2,2],0,0,0,A[3,3]]);
P:=evalm(N-A);
N1:=inverse(N);
M:=evalm(N1&*P);
c:=evalm(N1&*b);
nm:=norm(M,infinity);
erb1:=norm(c,infinity);

⎡8 0 0⎤
⎢ ⎥
N := ⎢ 0 5 0⎥
⎢ ⎥
⎣0 0 4⎦
⎡0 -1 0⎤
⎢ ⎥
P := ⎢-2 0 0⎥
⎢ ⎥
⎣-1 0 0⎦
⎡ 1 ⎤
⎢ 0 0 ⎥⎥
⎢ 8
⎢ ⎥
⎢ 1 ⎥
N1 := ⎢⎢ 0 0 ⎥⎥
⎢ 5 ⎥
⎢ ⎥
⎢ 1 ⎥
⎢⎢ 0 0 ⎥⎥
⎣ 4 ⎦
⎡ -1 ⎤
⎢ 0 0⎥⎥
⎢ 8
⎢ ⎥
⎢ -2 ⎥
M := ⎢⎢ 0 0⎥⎥
⎢ 5 ⎥
⎢ ⎥
⎢ -1 ⎥
⎢⎢ 0 0⎥⎥
⎣ 4 ⎦
⎡1 3 3⎤
c := ⎢⎢ , , ⎥⎥
⎣2 5 4⎦
2
nm :=
5
3
erb1 :=
4
Número de iteraciones para asegurar 8 decimales exactos. Si tomamos como vector incial el vector nulo, el valor de la primera
iteración coincide con c y el vector de error estimado en la primera iteración también coincide con c.
> n:='n';
ineq:=nm^n/(1-nm)*erb1<=0.5*10^(-8);
plot(ineq,n=12..30,thickness=3);
Page 7
 n := n
5 ⎛2⎞ n
ineq := ⎜⎜ ⎟⎟ ≤ .5000000000 10-8
4 ⎝5⎠

0.8

0.6

0.4

0.2

0 12 14 16 18 20 22 24 26 28 30
n

El gráfico nos muestra que la desigualdad es cierta para n mayor que 21, necesitamos 22 iteraciones.
Calculamos el valor de las iteraciones.
> Digits:=14;
A:=matrix(3,3,[8,1,0,2,5,0,1,0,4]);
b:=[4,3,3];
N:=matrix(3,3,[A[1,1],0,0,0,A[2,2],0,0,0,A[3,3]]);
P:=evalm(N-A);
N1:=inverse(N);
M:=evalm(N1&*P);
c:=evalm(N1&*b);
`*******conversión float *****`;
M:=evalf(evalm(M));
c:=evalf(evalm(c));
`****** método iterativo ******`;
xx.0:=[0,0,0];
n:=21;
for i from 0 to n do
`************* iteración `,i+1,`************`;
xx.(i+1):=evalm(M&*(xx.i)+c);
erb.(i+1):=evalm(xx.(i+1)-xx.i);
nerb.(i+1):=norm(erb.(i+1),infinity);
od:
evalm(xx22);
Digits := 14
⎡8 1 0⎤
⎢ ⎥
A := ⎢ 2 5 0⎥
⎢ ⎥
⎣1 0 4⎦
b := [ 4, 3, 3 ]
⎡8 0 0⎤
⎢ ⎥
N := ⎢ 0 5 0⎥
⎢ ⎥
⎣0 0 4⎦
⎡0 -1 0⎤
⎢ ⎥
P := ⎢-2 0 0⎥
⎢ ⎥
⎣-1 0 0⎦
⎡ 1 ⎤
⎢ 0 0 ⎥⎥
⎢ 8
⎢ ⎥
⎢ 1 ⎥
N1 := ⎢⎢ 0 0 ⎥⎥
⎢ 5 ⎥
⎢ ⎥
⎢ 1 ⎥
⎢⎢ 0 0 ⎥⎥
⎣ 4 ⎦

Page 8
 ⎡ -1 ⎤
⎢ 0 0⎥⎥
⎢ 8
⎢ ⎥
⎢ -2 ⎥
M := ⎢⎢ 0 0⎥⎥
⎢ 5 ⎥
⎢ ⎥
⎢ -1 ⎥
⎢⎢ 0 0⎥⎥
⎣ 4 ⎦
⎡1 3 3⎤
c := ⎢⎢ , , ⎥⎥
⎣2 5 4⎦
*******conversión float *****
⎡ 0 -.12500000000000 0⎤
⎢ ⎥
M := ⎢-.40000000000000 0 0⎥
⎢ ⎥
⎣-.25000000000000 0 0⎦
c := [ .50000000000000, .60000000000000, .75000000000000 ]
****** método iterativo ******
xx0 := [ 0, 0, 0 ]
n := 21
[ .44736842105263, .42105263157894, .63815789473684 ]
Calculamos el error.
> er22:=evalm(sf-xx22);
ner22:=norm(er22,infinity);
er22 := [ .4737 10-10, .2106 10-10, -.3684 10-10 ]
ner22 := .4737 10-10
Ejercicio 6-7
Vectores obtenidos en las 10 primeras iteraciones del método de Gauss-Seidel. Usamos vectores en lugar de matrices columna.
> restart;
with(linalg):
Digits:=14;
A:=matrix(3,3,[8,1,0,2,5,0,1,0,4]);
b:=[4,3,3];
N:=matrix(3,3,[8,0,0,2,5,0,1,0,4]);
P:=evalm(N-A);
N1:=inverse(N);
M:=evalm(N1&*P);
c:=evalm(N1&*b);
`*******conversión float *****`;
M:=evalf(evalm(M));
c:=evalf(evalm(c));
`****** método iterativo ******`;
xx.0:=[0,0,0];
n:=9;
for i from 0 to n do
`************* iteración`,i+1,`************`;
xx.(i+1):=evalm(M&*(xx.i)+c);
erb.(i+1):=evalm(xx.(i+1)-xx.i);
nerb.(i+1):=norm(erb.(i+1),infinity);
od;
Warning, new definition for norm
Warning, new definition for trace
Digits := 14
⎡8 1 0⎤
⎢ ⎥
A := ⎢ 2 5 0⎥
⎢ ⎥
⎣1 0 4⎦
b := [ 4, 3, 3 ]
⎡8 0 0⎤
⎢ ⎥
N := ⎢ 2 5 0⎥
⎢ ⎥
⎣1 0 4⎦
⎡0 -1 0⎤
⎢ ⎥
P := ⎢0 0 0⎥
⎢ ⎥
⎣0 0 90⎦
Page
 ⎡ 1 ⎤
⎢ 0 0 ⎥⎥
⎢ 8
⎢ ⎥
⎢ -1 1 ⎥
N1 := ⎢⎢ 0 ⎥⎥
⎢ 20 5 ⎥
⎢ ⎥
⎢ -1 1 ⎥
⎢⎢ 0 ⎥⎥
⎣ 32 4 ⎦
⎡ -1 ⎤
⎢ 0 0⎥⎥
⎢ 8
⎢ ⎥
⎢ 1 ⎥
M := ⎢⎢ 0 0⎥⎥
⎢ 20 ⎥
⎢ ⎥
⎢ 1 ⎥
⎢⎢ 0 0⎥⎥
⎣ 32 ⎦
⎡1 2 5⎤
c := ⎢⎢ , , ⎥⎥
⎣2 5 8⎦
*******conversión float *****
⎡0 -.12500000000000 0⎤
⎢ ⎥
M := ⎢0 .050000000000000 0⎥
⎢ ⎥
⎣0 .031250000000000 0⎦
c := [ .50000000000000, .40000000000000, .62500000000000 ]
****** método iterativo ******
xx0 := [ 0, 0, 0 ]
n := 9
************* iteración, 1, ************
xx1 := [ .50000000000000, .40000000000000, .62500000000000 ]
erb1 := [ .50000000000000, .40000000000000, .62500000000000 ]
nerb1 := .62500000000000
************* iteración, 2, ************
xx2 := [ .45000000000000, .42000000000000, .63750000000000 ]
erb2 := [ -.05000000000000, .02000000000000, .01250000000000 ]
nerb2 := .05000000000000
************* iteración, 3, ************
xx3 := [ .44750000000000, .42100000000000, .63812500000000 ]
erb3 := [ -.00250000000000, .00100000000000, .00062500000000 ]
nerb3 := .00250000000000
************* iteración, 4, ************
xx4 := [ .44737500000000, .42105000000000, .63815625000000 ]
erb4 := [ -.00012500000000, .00005000000000, .00003125000000 ]
nerb4 := .00012500000000
************* iteración, 5, ************
xx5 := [ .44736875000000, .42105250000000, .63815781250000 ]
erb5 := [ -.625000000 10-5, .250000000 10-5, .156250000 10-5 ]
nerb5 := .625000000 10-5
************* iteración, 6, ************
xx6 := [ .44736843750000, .42105262500000, .63815789062500 ]
erb6 := [ -.31250000 10-6, .12500000 10-6, .7812500 10-7 ]
nerb6 := .31250000 10-6
************* iteración, 7, ************
xx7 := [ .44736842187500, .42105263125000, .63815789453125 ]
erb7 := [ -.1562500 10-7, .625000 10-8, .390625 10-8 ]
nerb7 := .1562500 10-7
************* iteración, 8, ************
xx8 := [ .44736842109375, .42105263156250, .63815789472656 ]
Page 10
 erb8 := [ -.78125 10-9, .31250 10-9, .19531 10-9 ]
nerb8 := .78125 10-9
************* iteración, 9, ************
xx9 := [ .44736842105469, .42105263157813, .63815789473633 ]
erb9 := [ -.3906 10-10, .1563 10-10, .977 10-11 ]
nerb9 := .3906 10-10
************* iteración, 10, ************
xx10 := [ .44736842105273, .42105263157891, .63815789473682 ]
erb10 := [ -.196 10-11, .78 10-12, .49 10-12 ]
nerb10 := .196 10-11
Cálculo del error exacto.
> s:=linsolve(A,b);
sf:=evalf(evalm(s));
er10:=evalm(xx10-sf);
ner10:=norm(er10,infinity);
⎡ 17 8 97 ⎤
s := ⎢⎢ , , ⎥⎥
⎣ 38 19 152 ⎦
sf := [ .44736842105263, .42105263157895, .63815789473684 ]
er10 := [ .10 10-12, -.4 10-13, -.2 10-13 ]
ner10 := .10 10-12
Ejercicio 8
> restart;
with(linalg):
Warning, new definition for norm
Warning, new definition for trace
Calculamos la matriz M del método iterativo.
> A:=matrix(3,3,[4,1,a,1,4,1,1,1,4]);
N:=matrix(3,3,[4,0,0,0,4,0,0,0,4]);
P:=evalm(N-A);
N1:=inverse(N);
M:=evalm(N1&*P);
>
⎡4 1 a⎤
⎢ ⎥
A := ⎢ 1 4 1⎥
⎢ ⎥
⎣1 1 4⎦
⎡4 0 0⎤
⎢ ⎥
N := ⎢ 0 4 0⎥
⎢ ⎥
⎣0 0 4⎦
⎡0 -1 −a⎤
⎢ ⎥
P := ⎢-1 0 -1 ⎥
⎢ ⎥
⎣-1 -1 0⎦
⎡ 1 ⎤
⎢ 0 0 ⎥⎥
⎢ 4
⎢ ⎥
⎢ 1 ⎥
N1 := ⎢⎢ 0 0 ⎥⎥
⎢ 4 ⎥
⎢ ⎥
⎢ 1 ⎥
⎢⎢ 0 0 ⎥⎥
⎣ 4 ⎦
⎡ -1 1 ⎤
⎢ 0 − a ⎥⎥
⎢ 4 4
⎢ ⎥
⎢ -1 -1 ⎥
M := ⎢⎢ 0 ⎥
⎥
⎢ 4 4 ⎥
⎢ ⎥
⎢ -1 -1 ⎥
⎢⎢ 0 ⎥⎥
⎣ 4 4 ⎦
Exigimos que la norma de M sea inferior a 1
> ineq:=norm(M,infinity)<1;
⎛1 1 1⎞
ineq := max⎜⎜ + a , ⎟⎟ < 1
⎝ 4 4 11 2 ⎠
Page
> solve(ineq,a);
RealRange( Open( -3 ), Open( 3 ) )
Por lo tanto, si a toma valores entre -3 y 3, podemos asegurar que el método es convergente.
En el siguiente programa usamos la cota de un paso para detener las iteraciones.
> restart;
with(linalg):
Digits:=10;
a:=-1;
A:=matrix(3,3,[4,1,a,1,4,1,1,1,4]);
b:=[1,2,3];
N:=matrix(3,3,[4,0,0,0,4,0,0,0,4]);
P:=evalm(N-A);
N1:=inverse(N);
M:=evalm(N1&*P);
c:=evalm(N1&*b);
`*******conversión float *****`;
M:=evalf(evalm(M));
c:=evalf(evalm(c));
nm:=norm(M,infinity);
`****** método iterativo ******`;
xx.0:=[0,0,0];
t:=3;#nombre de decimals exactes
ermax:=0.5*10^(-t); # error máximo
n:=10; #número máximo de iteraciones
for i from 0 to n do
`*************`,i+1,`************`;
xx.(i+1):=evalm(M&*(xx.i)+c);
erb.(i+1):=evalm(xx.(i+1)-xx.i);
nerb.(i+1):=norm(erb.(i+1),infinity);
fer.(i+1):=nm/(1-nm)*nerb.(i+1);#usamos la cota en un paso para acotar el error.
if fer.(i+1)<ermax then
xs:=xx.(i+1); #La solució es guarda amb el nom xs
print(`***** precisión alcanzada ****`);
print(` solución =`, xs);
break;
fi;
od;
Warning, new definition for norm
Warning, new definition for trace
Digits := 10
a := -1
⎡4 1 -1⎤
⎢ ⎥
A := ⎢1 4 1⎥
⎢ ⎥
⎣1 1 4⎦
b := [ 1, 2, 3 ]
⎡4 0 0⎤
⎢ ⎥
N := ⎢ 0 4 0⎥
⎢ ⎥
⎣0 0 4⎦
⎡0 -1 1⎤
⎢ ⎥
P := ⎢-1 0 -1⎥
⎢ ⎥
⎣-1 -1 0⎦
⎡ 1 ⎤
⎢ 0 0 ⎥⎥
⎢ 4
⎢ ⎥
⎢ 1 ⎥
N1 := ⎢⎢ 0 0 ⎥⎥
⎢ 4 ⎥
⎢ ⎥
⎢ 1 ⎥
⎢⎢ 0 0 ⎥⎥
⎣ 4 ⎦

Page 12
 ⎡ -1 1 ⎤
⎢ 0 ⎥
⎢ 4 4 ⎥⎥
⎢
⎢ -1 -1 ⎥⎥
M := ⎢⎢ 0 ⎥
⎢ 4 4 ⎥
⎢ ⎥
⎢ -1 -1 ⎥
⎢⎢ 0 ⎥⎥
⎣ 4 4 ⎦
⎡1 1 3⎤
c := ⎢⎢ , , ⎥⎥
⎣4 2 4⎦
*******conversión float *****
⎡ 0 -.2500000000 .2500000000 ⎤
⎢ ⎥
M := ⎢-.2500000000 0 -.2500000000⎥
⎢ ⎥
⎣-.2500000000 -.2500000000 0 ⎦
c := [ .2500000000, .5000000000, .7500000000 ]
nm := .5000000000
****** método iterativo ******
xx0 := [ 0, 0, 0 ]
t := 3
ermax := .0005000000000
n := 10
*************, 1, ************
xx1 := [ .2500000000, .5000000000, .7500000000 ]
erb1 := [ .2500000000, .5000000000, .7500000000 ]
nerb1 := .7500000000
fer1 := .7500000000
*************, 2, ************
xx2 := [ .3125000000, .2500000000, .5625000000 ]
erb2 := [ .0625000000, -.2500000000, -.1875000000 ]
nerb2 := .2500000000
fer2 := .2500000000
*************, 3, ************
xx3 := [ .3281250000, .2812500000, .6093750000 ]
erb3 := [ .0156250000, .0312500000, .0468750000 ]
nerb3 := .0468750000
fer3 := .04687500000
*************, 4, ************
xx4 := [ .3320312500, .2656250000, .5976562500 ]
erb4 := [ .0039062500, -.0156250000, -.0117187500 ]
nerb4 := .0156250000
fer4 := .01562500000
*************, 5, ************
xx5 := [ .3330078125, .2675781250, .6005859375 ]
erb5 := [ .0009765625, .0019531250, .0029296875 ]
nerb5 := .0029296875
fer5 := .002929687500
*************, 6, ************
xx6 := [ .3332519532, .2666015625, .5998535156 ]
erb6 := [ .0002441407, -.0009765625, -.0007324219 ]
nerb6 := .0009765625
fer6 := .0009765625000
*************, 7, ************
xx7 := [ .3333129883, .2667236328, .6000366211 ]
erb7 := [ .0000610351, .0001220703, .0001831055 ]
nerb7 := .0001831055
Page 13
 fer7 := .0001831055000
***** precisión alcanzada ****
solución =, [ .3333129883, .2667236328, .6000366211 ]
Observa que en el programa anterior, la cota de error coincide con el error estimado, eso se debe a que la norma de M tiene el valor
0.5.
Error exacto.
> `****** solución y error exacto *****`;
s:=linsolve(A,b);
sf:=evalf(evalm(s));
er:=evalm(sf-xs);
ner:=norm(er,infinity);
****** solución y error exacto *****
⎡1 4 3⎤
s := ⎢⎢ , , ⎥⎥
⎣ 3 15 5 ⎦
sf := [ .3333333333, .2666666667, .6000000000 ]
er := [ .0000203450, -.0000569661, -.0000366211 ]
ner := .0000569661
Método de Gauss-Seidel
> restart;
with(linalg):
A:=matrix(3,3,[4,1,a,1,4,1,1,1,4]);
N:=matrix(3,3,[4,0,0,1,4,0,1,1,4]);
P:=evalm(N-A);
N1:=inverse(N);
M:=evalm(N1&*P);
nM:=norm(M,infinity);
solve(nM<1);
Warning, new definition for norm
Warning, new definition for trace
⎡4 1 a⎤
⎢ ⎥
A := ⎢ 1 4 1⎥
⎢ ⎥
⎣1 1 4⎦
⎡4 0 0⎤
⎢ ⎥
N := ⎢ 1 4 0⎥
⎢ ⎥
⎣1 1 4⎦
⎡0 -1 −a⎤
⎢ ⎥
P := ⎢0 0 -1 ⎥
⎢ ⎥
⎣0 0 0⎦
⎡ 1 ⎤
⎢ 0 0 ⎥⎥
⎢ 4
⎢ ⎥
⎢ -1 1 ⎥
N1 := ⎢⎢ 0 ⎥⎥
⎢ 16 4 ⎥
⎢ ⎥
⎢ -3 -1 1 ⎥
⎢⎢ ⎥⎥
⎣ 64 16 4 ⎦
⎡ -1 1 ⎤
⎢0 − ⎥ a
⎢ 4 4 ⎥
⎢ ⎥
⎢ 1 1 1 ⎥⎥
M := ⎢⎢ 0 a− ⎥
⎢ 16 16 4 ⎥
⎢ ⎥
⎢ 3 3 1 ⎥
⎢⎢ 0 a + ⎥⎥
⎣ 64 64 16 ⎦
⎛1 1 1 1 1 3 3 1 ⎞
nM := max⎜⎜ + a , + a− , + a+ ⎟⎟
⎝4 4 16 16 4 64 64 16 ⎠
RealRange( Open( -3 ), Open( 3 ) )
Si a toma valores entre -3 y 3 podemos asegurar que el método es convergente.
> restart;
with(linalg):
a:=-1;
A:=matrix(3,3,[4,1,a,1,4,1,1,1,4]);
Page 14
 b:=[1,2,3];
N:=matrix(3,3,[4,0,0,1,4,0,1,1,4]);
P:=evalm(N-A);
N1:=inverse(N);
M:=evalm(N1&*P);
c:=evalm(N1&*b);
`*******conversión float *****`;
M:=evalf(evalm(M));
c:=evalf(evalm(c));
nm:=norm(M,infinity);
`****** método iterativo ******`;
xx.0:=[0,0,0];
t:=3;#nombre de decimals exactes
ermax:=0.5*10^(-t); # error máximo
n:=10; #número máximo de iteraciones
for i from 0 to n do
`*************`,i+1,`************`;
xx.(i+1):=evalm(M&*(xx.i)+c);
erb.(i+1):=evalm(xx.(i+1)-xx.i);
nerb.(i+1):=norm(erb.(i+1),infinity);
fer.(i+1):=nm/(1-nm)*nerb.(i+1);#usamos la cota en un paso para acotar el error.
if fer.(i+1)<ermax then
xs:=xx.(i+1); #La solució es guarda amb el nom xs
print(`***** precisión alcanzada ****`);
print(` solución =`, xs);
break;
fi;
od;
Warning, new definition for norm
Warning, new definition for trace
a := -1
⎡4 1 -1⎤
⎢ ⎥
A := ⎢1 4 1⎥
⎢ ⎥
⎣1 1 4⎦
b := [ 1, 2, 3 ]
⎡4 0 0⎤
⎢ ⎥
N := ⎢ 1 4 0⎥
⎢ ⎥
⎣1 1 4⎦
⎡0 -1 1⎤
⎢ ⎥
P := ⎢0 0 -1⎥
⎢ ⎥
⎣0 0 0⎦
⎡ 1 ⎤
⎢ 0 0 ⎥⎥
⎢ 4
⎢ ⎥
⎢ -1 1 ⎥
N1 := ⎢⎢ 0 ⎥⎥
⎢ 16 4 ⎥
⎢ ⎥
⎢ -3 -1 1 ⎥
⎢⎢ ⎥⎥
⎣ 64 16 4 ⎦
⎡ -1 1 ⎤
⎢ 0 ⎥
⎢ 4 4 ⎥⎥
⎢
⎢ 1 -5 ⎥⎥
M := ⎢⎢ 0 ⎥
⎢ 16 16 ⎥
⎢ ⎥
⎢ 3 1 ⎥
⎢⎢ 0 ⎥⎥
⎣ 64 64 ⎦
⎡ 1 7 37 ⎤
c := ⎢⎢ , , ⎥⎥
⎣ 4 16 64 ⎦
*******conversión float *****
⎡0 -.2500000000 .2500000000 ⎤
⎢ ⎥
M := ⎢0 .06250000000 -.3125000000 ⎥
⎢ ⎥
⎣0 .04687500000 .01562500000⎦
Page 15
 c := [ .2500000000, .4375000000, .5781250000 ]
nm := .5000000000
****** método iterativo ******
xx0 := [ 0, 0, 0 ]
t := 3
ermax := .0005000000000
n := 10
*************, 1, ************
xx1 := [ .2500000000, .4375000000, .5781250000 ]
erb1 := [ .2500000000, .4375000000, .5781250000 ]
nerb1 := .5781250000
fer1 := .5781250000
*************, 2, ************
xx2 := [ .2851562500, .2841796875, .6076660156 ]
erb2 := [ .0351562500, -.1533203125, .0295410156 ]
nerb2 := .1533203125
fer2 := .1533203125
*************, 3, ************
xx3 := [ .3308715820, .2653656006, .6009407043 ]
erb3 := [ .0457153320, -.0188140869, -.0067253113 ]
nerb3 := .0457153320
fer3 := .04571533200
*************, 4, ************
xx4 := [ .3338937760, .2662913799, .5999537110 ]
erb4 := [ .0030221940, .0009257793, -.0009869933 ]
nerb4 := .0030221940
fer4 := .003022194000
*************, 5, ************
xx5 := [ .3334155828, .2666576765, .5999816852 ]
erb5 := [ -.0004781932, .0003662966, .0000279742 ]
nerb5 := .0004781932
fer5 := .0004781932000
***** precisión alcanzada ****
solución =, [ .3334155828, .2666576765, .5999816852 ]
Vemos que la precisión exigida se alcanza en 5 pasos. A continuación calculamos el error.
> `****** solución y error exacto *****`;
s:=linsolve(A,b);
sf:=evalf(evalm(s));
er:=evalm(sf-xs);
ner:=norm(er,infinity);
****** solución y error exacto *****
⎡1 4 3⎤
s := ⎢⎢ , , ⎥⎥
⎣ 3 15 5 ⎦
sf := [ .3333333333, .2666666667, .6000000000 ]
er := [ -.0000822495, .89902 10-5, .0000183148 ]
ner := .0000822495
Ejercicio 9
matriz del método
> a:='a';
N:=matrix(2,2,[1,0,-a,1]);
P:=matrix(2,2,[0,a,0,0]);
N1:=inverse(N);
M:=evalm(N1&*P);
nM:=norm(M,infinity);
Page 16
 solve(nM<1);

a := a
⎡1 0⎤
N := ⎢ ⎥
⎣−a 1⎦
⎡0 a⎤
P := ⎢ ⎥
⎣0 0⎦
⎡1 0⎤
N1 := ⎢ ⎥
⎣a 1⎦
⎡0 a⎤
M := ⎢ ⎥
⎣0 a2 ⎦
nM := max( a 2, a )
RealRange( Open( -1 ), Open( 1 ) )
Si tomamos -1<a<1 , podemos asegurar la convergencia del método.
Ejercicio 12
> with(linalg):
M:=matrix(3,3,[0,-0.1,-0.2,0.1,0,0.2,0.1,-0.1,0.3]);
⎡0 -.1 -.2⎤
⎢ ⎥
M := ⎢.1 0 .2 ⎥
⎢ ⎥
⎣.1 -.1 .3 ⎦
> nm:=norm(M,infinity);
nm := .5
> e0:=[1,-1,2];
n0:=norm(e0,infinity);
e0 := [ 1, -1, 2 ]
n0 := 2
> cota:=nm^5*n0;
cota := .06250
> e5:=evalm(M^5&*e0);
e5 := [ .00045, -.00067, -.00064 ]
> n5:=norm(e5,infinity);
n5 := .00067
>

Page 17