METODO A=LU

Programa:
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);

Ejercicio:
A=[2 1 0 0;1 4 1 0;0 1 4 1;0 0 1 2]

A =

2 1 0 0
1 4 1 0
0 1 4 1
0 0 1 2

>> b=[8;-10;5;3]

b =

8
-10
5
3

>> [L U]=lu(A)

L =

1.0000 0 0 0
0.5000 1.0000 0 0
0 0.2857 1.0000 0
0 0 0.2692 1.0000

U =

2.0000 1.0000 0 0
0 3.5000 1.0000 0
0 0 3.7143 1.0000
0 0 0 1.7308
 METODO PA=LU
Programa:
function [P, L, U,x] = plu(A,b)
[m, n] = size(A);
if m ~= n
error('La matriz debe ser cuadrada')
end
P = eye(n, n);
L = eye(n, n);
U = zeros(n, n);
tol = sqrt(eps);
sign = 1;

for k = 1:n
if abs(A(k, k)) < tol
for r = k:n
if abs(A(r, k)) >= tol
break
end
if r == n
if nargout == 4
sign = 0;
return
else
disp('A es singular con tolerancia')
error(['No hay pivotaje en las columnas' int2str(k) '.'])
end
end
end
A([r k], 1:n) = A([k r], 1:n);
if k > 1, L([r k], 1:k-1) = L([k r], 1:k-1);
end
P([r k], 1:n) = P([k r], 1:n);
sign = -sign;
end
for i = k+1:n
L(i, k) = A(i, k) / A(k, k);
for j = k+1:n
A(i, j) = A(i, j) - L(i, k)*A(k, j);
end
end
for j = k:n
U(k, j) = A(k, j) * (abs(A(k, j)) >= tol);
end
end

Z=P*b;
Y=inv(L)*Z;
x=inv(U)*Y;
L
U
P
disp('La solución del sistema es:')
disp(x)
end
Ejercicio:
A=[2 1 0 0;1 4 1 0;0 1 4 1;0 0 1 2]

A =

2 1 0 0
1 4 1 0
0 1 4 1
0 0 1 2

>> b=[8;-10;5;3]

b =

8
-10
5
3

>> [P, L, U,x] = plu(A,b)

L =

1.0000 0 0 0
0.5000 1.0000 0 0
0 0.2857 1.0000 0
0 0 0.2692 1.0000

U =

2.0000 1.0000 0 0
0 3.5000 1.0000 0
0 0 3.7143 1.0000
0 0 0 1.7308

P =

1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1

La solución del sistema es:

6.3333
-4.6667
2.3333
0.3333
 DOOLITTLE: A=LU
Programa:
function [L U]=doolittle(A)
%Este programa factoriza la matriz A en la forma LU
%donde L es triangular inferior unitaria
% U es triangular superior
n=length(A(:,1));
for k=1:n-1
for i=k+1:n
m(i,k)=A(i,k)/A(k,k);
A(i,k)=m(i,k);
A(i,k+1:n)=A(i,k+1:n)-m(i,k)*A(k,k+1:n);
end
end
U=triu(A);
for k=1:n
A(k,k)=1;
end
L=tril(A);

function [L D]=facldlt(A)
n=size(A,1);
L=eye(n);
D=zeros(n);
for i=1:n-1
for j=i+1:n
q=0;
for k=1:i-1
q=q+((L(i,k))^2)*D(k,k);
end
D(i,i)=A(i,i)-q;
x=0;
for s=1:i-1
x=x+L(j,s)*L(i,s)*D(s,s);
end
L(j,i)=(A(j,i)-x)/(D(i,i));
end
end
g=0;
for w=1:n-1
g=g+((L(n,w))^2)*D(w,w);
end
D(n,n)=A(n,n)-g;
Ejercicio:
A=[2 1 0 0;1 4 1 0;0 1 4 1;0 0 1 2]

A =

2 1 0 0
1 4 1 0
0 1 4 1
0 0 1 2

>> b=[8;-10;5;3]

b =

8
-10
5
3

>> [L U]=doolittle(A)

L =

1.0000 0 0 0
0.5000 1.0000 0 0
0 0.2857 1.0000 0
0 0 0.2692 1.0000

U =

2.0000 1.0000 0 0
0 3.5000 1.0000 0
0 0 3.7143 1.0000
0 0 0 1.7308
 METODO DE CHOLESKY: A=L*L’
Programa:
function choleski(A)
%Este programa factoriza la matriz A simetrica definida
%positiva en la forma LL'
%donde L es triangular inferior
% U es triangular superior unitaria
n=length(A(:,1));
L=zeros(n,n);
L(1,1)=sqrt(A(1,1));
L(2:n,1)=A(2:n,1)/L(1,1);
for k=2:n
L(k,k)=A(k,k)-L(k,1:k-1)*(L(k,1:k-1))';
L(k,k)=sqrt(L(k,k));
for j=k+1:n
L(j,k)=(A(j,k)-L(j,1:k-1)*(L(k,1:k-1))')/L(k,k);
end
end
L

Ejercicio:
A=[2 1 0 0;1 4 1 0;0 1 4 1;0 0 1 2]

A =

2 1 0 0
1 4 1 0
0 1 4 1
0 0 1 2

>> b=[8;-10;5;3]

b =

8
-10
5
3

>> choleski(A)

L =

1.4142 0 0 0
0.7071 1.8708 0 0
0 0.5345 1.9272 0
0 0 0.5189 1.3156

L'

ans =

1.0000 0.5000 0 0
0 1.0000 0.2857 0
0 0 1.0000 0.2692
 0 0 0 1.0000

METODO DE CHOLESKY: A=L*D*L’

Programa:
function [L,D]=ldlt(A)
% Figure out the size of A.
n=size(A,1);
%
% The main loop. See Golub and Van Loan for details.
%
L=zeros(n,n);
for j=1:n,
if (j > 1),
v(1:j-1)=L(j,1:j-1).*d(1:j-1);
v(j)=A(j,j)-L(j,1:j-1)*v(1:j-1)';
d(j)=v(j);
if (j < n),
L(j+1:n,j)=(A(j+1:n,j)-L(j+1:n,1:j-1)*v(1:j-1)')/v(j);
end;
else
v(1)=A(1,1);
d(1)=v(1);
L(2:n,1)=A(2:n,1)/v(1);
end;
end;
% Put d into a matrix.
%
D=diag(d);
% Put ones on the diagonal of L.
%
L=L+eye(n);

Ejercicio:

A=[2 1 0 0;1 4 1 0;0 1 4 1;0 0 1 2]

A =

2 1 0 0
1 4 1 0
0 1 4 1
0 0 1 2

>> b=[8;-10;5;3]

b =

8
-10
5
3

>> [L,D]=ldlt(A)

L =

1.0000 0 0 0
 0.5000 1.0000 0 0
0 0.2857 1.0000 0
0 0 0.2692 1.0000

D =

2.0000 0 0 0
0 3.5000 0 0
0 0 3.7143 0
0 0 0 1.7308

>> L'

ans =

1.0000 0.5000 0 0
0 1.0000 0.2857 0
0 0 1.0000 0.2692
0 0 0 1.0000

>> y=inv(L)*b

y =

8.0000
-14.0000
9.0000
0.5769

>> z=inv(D)*y

z =

4.0000
-4.0000
2.4231
0.3333

>> x=inv(L')*z

x =

6.3333
-4.6667
2.3333
0.3333
 METODO DE GRAN SMIT: A=QR

Programa:

unction [Q R]=gransm(A)
n=size(A,1);
m=size(A,2);
u1=A(:,1);
fprintf('u1\n');
disp(u1);
e1=u1/(norm(u1));
fprintf('e1\n');
disp(e1)
Q=zeros(n,m);
Q(:,1)=e1;
for i=2:m
s=0;
for j=2:i
s=s+(((A(:,i))'*Q(:,j-1))/(norm(Q(:,j-1))))*Q(:,j-1);
end
u=A(:,i)-s;
e=(u)/(norm(u));
Q(:,i)=e;
fprintf('u%i\n',i);
disp(u);
fprintf('e%i\n',i)
disp(e);

end
R=Q'*A;
end

Ejercicio:

A=[-2 3 6 2;4 2 1 5;0 3 1 6;4 1 3 2]

A =

-2 3 6 2
4 2 1 5
0 3 1 6
4 1 3 2

>> [Q R]=gransm(A)
u1
-2
4
0
4
e1
-0.3333
0.6667
0
0.6667

u2
3.3333
1.3333
3.0000
0.3333

e2
0.7107
0.2843
0.6396
0.0711

u3
2.3838
-0.9798
-2.4545
2.1717

e3
0.5717
-0.2350
-0.5887
0.5209

u4
-0.0732
-0.1987
0.1517
0.1621

e4
-0.2386
-0.6477
0.4943
0.5284

Q =

-0.3333 0.7107 0.5717 -0.2386

0.6667 0.2843 -0.2350 -0.6477
0 0.6396 -0.5887 0.4943
0.6667 0.0711 0.5209 0.5284

R =

6.0000 1.0000 0.6667 4.0000

0.0000 4.6904 5.4011 6.8224
-0.0000 -0.0000 4.1694 -2.5220
0.0000 -0.0000 0.0000 0.3068
 METODO DE GIVENS: A=QR

Programa:
function [Q,R]=givens(A)
[m,n]=size(A);
if m~=n
'matriz no cuadrada'
return
end
A0=A;
i=1;
k=1;
P=eye(n);
while i<n+1
j=i+1;
while j<m+1
if k<10
if A(j,i)==0
fprintf('A%i=\n',k)
disp(A);
else
c(1,1)=A(i,i);
c(1,2)=A(i,j);
c(2,1)=A(j,i);
c(2,2)=A(j,j);
fprintf('\n\n\nc%i=\n',k)
disp(c);
tit=atand(-c(2,1)/c(1,1))
G=eye(n);
G(i,i)=cosd(tit);
G(j,j)=cosd(tit);
G(j,i)=sind(tit);
G(i,j)=-sind(tit);
fprintf('G%i=\n',k)
disp(G);
fprintf('A%i=\n',k)
A=G*A;
disp(A);
end
end
k=k+1;
j=j+1;
P=G*P;
end
i=i+1;
end
q=P;
Q=q';
R=P*A0;
End
Ejercicio:

A=[-2 3 6 2;4 2 1 5;0 3 1 6;4 1 3 2]

A =

-2 3 6 2
4 2 1 5
0 3 1 6
4 1 3 2

>> [Q,R]=givens(A)

c1=
-2 3
4 2

tit =

63.4349

G1=
0.4472 -0.8944 0 0
0.8944 0.4472 0 0
0 0 1.0000 0
0 0 0 1.0000

A1=
-4.4721 -0.4472 1.7889 -3.5777
0.0000 3.5777 5.8138 4.0249
0 3.0000 1.0000 6.0000
4.0000 1.0000 3.0000 2.0000

A2=
-4.4721 -0.4472 1.7889 -3.5777
0.0000 3.5777 5.8138 4.0249
0 3.0000 1.0000 6.0000
4.0000 1.0000 3.0000 2.0000

c3=
-4.4721 -3.5777
4.0000 2.0000

tit =

41.8103

G3=
 0.7454 0 0 -0.6667
0 1.0000 0 0
0 0 1.0000 0
0.6667 0 0 0.7454

A3=
-6.0000 -1.0000 -0.6667 -4.0000
0.0000 3.5777 5.8138 4.0249
0 3.0000 1.0000 6.0000
0 0.4472 3.4286 -0.8944

c4=
3.5777 5.8138
3.0000 1.0000

tit =

-39.9807

G4=
1.0000 0 0 0
0 0.7663 0.6425 0
0 -0.6425 0.7663 0
0 0 0 1.0000

A4=
-6.0000 -1.0000 -0.6667 -4.0000
0.0000 4.6690 5.0974 6.9393
-0.0000 -0.0000 -2.9693 2.0114
0 0.4472 3.4286 -0.8944

c5=
4.6690 6.9393
0.4472 -0.8944

tit =

-5.4712

G5=
1.0000 0 0 0
0 0.9954 0 0.0953
0 0 1.0000 0
0 -0.0953 0 0.9954

A5=
-6.0000 -1.0000 -0.6667 -4.0000
0.0000 4.6904 5.4011 6.8224
-0.0000 -0.0000 -2.9693 2.0114
-0.0000 0.0000 2.9270 -1.5520
c6=
-2.9693 2.0114
2.9270 -1.5520

tit =

44.5893

G6=
1.0000 0 0 0
0 1.0000 0 0
0 0 0.7122 -0.7020
0 0 0.7020 0.7122

A6=
-6.0000 -1.0000 -0.6667 -4.0000
0.0000 4.6904 5.4011 6.8224
-0.0000 -0.0000 -4.1694 2.5220
-0.0000 -0.0000 -0.0000 0.3068

Q =

-0.4472 0.5721 -0.0455 -0.6860

-0.5963 -0.5085 0.6165 -0.0762
0 0.6396 0.5887 0.4943
-0.6667 0.0711 -0.5209 0.5284

R =

-4.1574 -3.2009 -5.2796 -5.2092

-2.8939 2.6891 3.7768 2.5813
0.4734 2.3417 -0.6305 5.4819
3.1807 -0.1993 -2.1130 2.2694

>> C=Q*R

C =

-2.0000 3.0000 6.0000 2.0000

4.0000 2.0000 1.0000 5.0000
0.0000 3.0000 1.0000 6.0000
4.0000 1.0000 3.0000 2.0000
 METODO DE HOUSEHOLDER: A= Q*R

Programa:

function [Q R]=hous(A)
m=size(A,1)
A0=A;
Q0=eye(m);
for k=1:m-1
fprintf('\n para K=%i',k);
a=A(:,k);
s=0;
for j=k:m
s=s+a(j)^2;
end
n=sqrt(s)
for j=1:k-1
a(j)=0;
end
x=norm(a(k));
g=sign(a(k))
a(k)=a(k)+g*n
u=(1/sqrt(2*n*(x+n)))*a
H=eye(m)-2*u*u'
A=H*A
Q0=H*Q0;
end
R=A;
Q=Q0';
end

Ejercicio:

A=[-2 3 6 2;4 2 1 5;0 3 1 6;4 1 3 2]

A =

-2 3 6 2
4 2 1 5
0 3 1 6
4 1 3 2

>> [Q R]=hous(A)

m =

para K=1
n =

6
g =

-1

a =

-8
4
0
4

u =

-0.8165
0.4082
0
0.4082

H =

-0.3333 0.6667 0 0.6667

0.6667 0.6667 0 -0.3333
0 0 1.0000 0
0.6667 -0.3333 0 0.6667

A =

6.0000 1.0000 0.6667 4.0000

-0.0000 3.0000 3.6667 4.0000
0 3.0000 1.0000 6.0000
-0.0000 2.0000 5.6667 1.0000

para K=2
n =

4.6904

g =

a =

0
7.6904
3.0000
2.0000

u =

0
0.9054
 0.3532
0.2355

H =

1.0000 0 0 0
0 -0.6396 -0.6396 -0.4264
0 -0.6396 0.7505 -0.1663
0 -0.4264 -0.1663 0.8891

A =

6.0000 1.0000 0.6667 4.0000

0.0000 -4.6904 -5.4011 -6.8224
0.0000 0.0000 -2.5373 1.7782
-0.0000 0.0000 3.3085 -1.8145

para K=3
n =

4.1694

g =

-1

a =

0
0
-6.7067
3.3085

u =

0
0
-0.8968
0.4424

H =

1.0000 0 0 0
0 1.0000 0 0
0 0 -0.6086 0.7935
0 0 0.7935 0.6086

A =

6.0000 1.0000 0.6667 4.0000

0.0000 -4.6904 -5.4011 -6.8224
 -0.0000 -0.0000 4.1694 -2.5220
0.0000 0.0000 -0.0000 0.3068

Q =

-0.3333 -0.7107 0.5717 -0.2386

0.6667 -0.2843 -0.2350 -0.6477
0 -0.6396 -0.5887 0.4943
0.6667 -0.0711 0.5209 0.5284

R =

6.0000 1.0000 0.6667 4.0000

0.0000 -4.6904 -5.4011 -6.8224
-0.0000 -0.0000 4.1694 -2.5220
0.0000 0.0000 -0.0000 0.3068

A=Q*R

A =

-2.0000 3.0000 6.0000 2.0000

4.0000 2.0000 1.0000 5.0000
0.0000 3.0000 1.0000 6.0000
4.0000 1.0000 3.0000 2.0000
 METODO DE GAUSS-SIEDEL
Programa:

function X=GaussSeidel(A,B,tol,max)
%
% Datos de entrada
% P es el dato inicial, un vector de orden nx1
% tol es la tolerancia
% max es el numero maximo de iteraciones
%
% Datos de salida
% X es una matriz de orden nx1 con la aproximacion a la
% solucion de AX=B obtenida por el metodo de GaussSeidel
%
format short
% lee la matriz A, matriz cuadrada invertible de orden n,
% y el vector B, de orden nx1, al ejecutar el fichero
sistemaproblema2tema2
n=length(B);
P=zeros(n,1);
c=0;
for k=1:max
% construccion de la siguiente iteracion por el metodo de GaussSeidel
for j=1:n
if j==1
X(1)=(B(1)-A(1,2:n)*P(2:n))/A(1,1);
elseif j==n
X(n)=(B(n)-A(n,1:n-1)*(X(1:n-1))')/A(n,n);
else
X(j)=(B(j)-A(j,1:j-1)*(X(1:j-1))'-A(j,j+1:n)*P(j+1:n))/A(j,j);
end
end
% condicion de paro
ea=abs(norm(X'-P));
er=ea/(norm(X)+eps);
if(ea<tol)|(er<tol)
disp('Se alcanzo la tolerancia con exito en la iteracion')
k
disp('y la solucion aproximada es')
X=X';
c=1;
break
else
P=X';
end
disp(X);
end
% no cumplimiento de la condicion de paro
if c==0
disp('El metodo no cumple el criterio de paro propuesto para')
max
disp('iteraciones.')
end
Ejercicio:

X=GaussSeidel(A,b,0.001,10)
4.0000 -3.5000 2.1250 0.4375

5.7500 -4.4688 2.2578 0.3711

6.2344 -4.6230 2.3130 0.3435

6.3115 -4.6561 2.3282 0.3359

6.3281 -4.6641 2.3320 0.3340

Se alcanzo la tolerancia con exito en la iteracion

k =

y la solucion aproximada es

X =

6.3320
-4.6660
2.3330
0.3335

METODO DE JACOBI

Programa:

function x=jacobi(A,b,x0,tol,M)
%Datos: x0 vector inicial
% M numero maximo de iteraciones
% tol tolerancia para x
n=length(b);
for k=1:M
for j=1:n
x(j)=(b(j)-A(j,[1:j-1,j+1:n])*x0([1:j-1,j+1:n]))/A(j,j);
end
err=abs(norm(x'-x0));
x0=x';
if(err<tol)|(k==M)
break
end
end
x=x';

Ejercicio:

x=jacobi(A,b,x0,0.001,10)
x =

6.3298
-4.6637
2.3298
0.3363
METODO DE SOR

Programa:
function [x,iter,resid]=SOR(a,b,om,x0,nmax,toll)
%GSEIDEL Metodo SOR per sistemi lineari
% [X,ITER,RESID]=SOR(A,B,OM,X0,NMAX,TOLL) risolve il sistema
% lineare A*X=B con il metodo iterativo SOR a
% partire da un dato iniziale X0.
%
% Il metodo si arresta quando la norma 2 del residuo
% normalizzato al residuo iniziale e' minore della
% tolleranza TOLL o quando viene raggiunto il massimo
% numero di iterazioni NMAX.
%
% La soluzione approssimata viene memorizzata nel
% vettore X, mentre in ITER viene riportato il
% numero di iterazioni che e' stato necessario per
% ottenerla.
% In RESID viene memorizzata la storia dei residui.
[n,n]=size(a);
iter = 0;
r = b - a * x0;
r0 = norm(r);
err = norm (r);
x = x0';
while err > toll & iter < nmax
iter = iter + 1;
for i=1:n
s = sum(a(i,1:i-1).*x(1:i-1));
s = s + sum(a(i,i+1:end).*x(i+1:end));
xold=x(i);
xGS = ( b(i) - s) / a(i,i);
x (i) = om*xGS + (1-om)*xold;
( b(i) - s) / a(i,i);
end
r = b - a * x';
err = norm (r) / r0;
resid(iter)=err;
end

return

Ejercicio:

[x,iter,resid]=SOR(A,b,1,x0,10,0.001)

x =

6.3281 -4.6641 2.3320 0.3340

iter =

5
resid =

0.2926 0.0697 0.0118 0.0026 0.0006