Metodos Numericos

ETN-505

Pactica No 3
MATRICES Y SISTEMAS DE ECUACIONES
LINEALES

Docente:
Ing. Ramiro Puch

Estudiante:
Univ: Marcos Daniel Vasquez Chuquimia

Verano/ 2017
 1. CALCULO DE LA INVERSA DE UNA MATRIZ POR EL MTODO DE GAUSS:
Para calcular la inversa de una matriz cuadrada A, aplicando
el mtodo de Gauss, construimos, en primer lugar, la matriz
( A | I ), siendo I la matriz identidad del mismo orden que A.
Despus de realizar diversas operaciones sobre las filas de
sta nueva matriz, tendremos que conseguir que se transforme en
la siguiente ( I | B ). La matriz B ser la inversa de la
matriz A, es decir: B = A-1.

Las operaciones que podemos realizar con las filas de la citada

matriz son:

a) Multiplicar o dividir una fila por un nmero distinto de cero.

b) Sumarle a una fila otra fila multiplicada por un nmero

distinto de cero.

En las escena inferior izquierda se describe el proceso, paso a paso

mediante un ejemplo, para calcular la inversa de una matriz de orden
3 aplicando el mtodo de Gauss.

Al pulsar sobre los botones de la parte inferior derecha se abren

sendas escenas que permiten calcular la inversa de cualquier matriz
de orden 2 o 3 por el mtodo de Gauss, tambin con una descripcin
de los pasos realizados.
%CALCULO DE LA MATRIZ INVERSA PASO A PASO
ren = input('Tamao n: ');
reiniciar=ren;
x=2;
acu=0;
y=ren-1;
dec=ren;
mov=ren-1;
a=1;
b=1;
fila=1;
i=1;
d=1;
e=1;
au=ren-1;
in=1;
columna=2;
repeticiones=0;
repeticiones2=0;
lim=ren;
dar=1;
% variables para solucionar problemas con el cero
temporal=0;
menor=1;
np=ren;
paratod=ren;
increm=1;
parcon=0;
temporaliden=0;
% para generar la matriz
for r = 1 : ren
for c = 1 : ren
s = ['Dato (' num2str(r) ', ' num2str(c) '): '];
m(r, c) = input(s);
end
end
m
% para generar la matriz identidad
for r = 1 : ren
for c = 1 : ren
if(r==c)
n(r, c) =1;
else
n(r, c) =0;
end
end
end
n
% para generar la matriz aumentada
o=[m n];
o
% para calcular la determinante
fprintf('determinante: %5.2f\n',det(m))
% PROCESO PARA CAMBIAR FILAS Y EVITAR INDETERMINACIONES
if(det(m)~=0)

while (menor<=np)
for r = 1 : np
for c = 1 : np

if((r==c)&&(r>parcon)&&(c>parcon))
ren=np;
end

if((r==c)&&(m(r,c)==0))
for indar=1: np
temporal=m(r,:);
m(r,:)=m(ren,:);
m(ren,:)=temporal;

temporaliden=n(r,:);
n(r,:)=n(ren,:);
n(ren,:)=temporaliden;

end
o=[m n];
o
end
if((r==c)&&(r<parcon)&&(c<parcon))
ren=ren+1;
end
end
end
ren=np-increm;
increm=increm+1;
menor=menor+1;
parcon=parcon+1;
end
ren=reiniciar;

% HASTA AQUI PARA CAMBIAR FILAS

o=[m n];
o
% PROCESO PARA CONSEGUIR LA MITAD DE LA FUNCION INVERSA
disp('Proceso para diagonal inferior')
while(a<=ren)
for r = a : ren
for c = b : ren

if(r==fila)
n(fila,:)=n(fila,:)/m(fila,fila);
m(fila,:)=m(fila,:)/m(fila,fila);
end

if(r==x)
n(x,:)=n(x,:)-(n(a,:)*m(x,fila));
m(x,:)=m(x,:)-(m(a,:)*m(x,fila));
end

repeticiones=repeticiones+1;
end
if(r==i)
x=i;
 end

o=[m n];
o
x=x+1;

end
if (r==ren&&c==ren)

a=a+1;
b=b+1;
fila=fila+1;
x=b+1;
i=i+1;
end
end
ren=reiniciar;
% PROCESO PARA COMPLETAR LA MATRIZ INVERSA
disp('para diagonal superior')
while(0<ren)
for r =ren :-1: 1
for c =ren :-1: 1

if((r-1)==y)
n(y,:)=n(y,:)-(n(dec,:)*m(y,dec));
m(y,:)=m(y,:)-(m(dec,:)*m(y,dec));
end
repeticiones2=repeticiones2+1;
acu=c;
end
o=[m n];
o
y=y-1;

if(y==0)
ren=0;
end
end
ren=lim-dar;
if (r==1&&acu==1)

dar=dar+1;
dec=dec-1;
au=au-1;
y=au;
end
if(au==0)
ren=0;
end
end
% AQUI VA REPETICIONES 1 Y 2
else
disp('NO EXISTE LA MATRIZ INVERSA');
end
disp('SU MATRIZ FINAL ES:');
o=[m n];
o
Calculo de laa Matriz Inversa 4x4 con el anterior programa:

Introducinedo los elementos de la Matriz A al programa:

1 0 -2 7
A = 1 1 2 5
0 1 3 2
2 2 4 9

Nos da el siguiente resultado:

2. Mtodo de eliminacin de Gauss simple

El procedimiento est diseado para resolver un sistema de n
ecuaciones lineales

La tcnica consiste en dos etapas: la eliminacin de las

incgnitas y su solucin mediante la sustitucin hacia atrs.
Primero dividimos por a11 obteniendo:

Ahora eliminamos x11 de la segunda, tercera, etc. de las

ecuaciones y obtenemos un sistema modificado de (n 1)
ecuaciones:
Donde el ndice superior 1 indica que son los valores
modificados de la primera
eliminacin.

Un procedimiento similar se usa para eliminar x2 de las ecuaciones

y as
sucesivamente.
Un algoritmo general para la eliminacin de xk es:

Despus que el procedimiento anterior se ha aplicado (n -1) veces,

el conjunto original de ecuaciones se reduce a la siguiente
ecuacin simple:

Despejando para xn:

Despus que el proceso de eliminacin se haya completado, el

sistema original de ecuaciones se ha transformado en un sistema
triangular superior, con la diagonal de coeficientes unitarios. La
forma general para la fila k es ahora:
Habiendo calculado xn de la ecuacin, calculamos las incgnitas
restantes, sucesivamente, aplicando en orden inverso, la formula:

A continuacin se resuelve un ejemplo manualmente, aplicando el

algoritmo anterior.
Entonces se tendr el programa codificado en MatLab:

% ELIMINACION GAUSSIANA SIMPLE

clc %permite borrar el area de trabajo

clear %permite borrar las variables almacenadas
format long %permite utilizar la maxima capacidad de la maquina

fprintf(' ELIMINACION GAUSSIANA SIMPLE (SOLUCIN POR

ETAPAS)\n\n\n');
%fprintf me permite ingresar comentarios de manera textual que pueden
%orientar al usuario en el uso del programa

%input es un comando de solicitud de entrada de datos del usuario.

A=input('Ingrese la matriz A = \n');
b=input('\nIngrese el vector b, correspondite a los terminos
independientes b=\n');
% Las matrices A y b deben ser ingresadas entre corchetes separando las
%columnas mediante coma ',' y las filas mediante punto y coma ';'.

%permite obtener el tamao de la matriz A

[n,m]=size(A);
C=[A,b];
% la matriz C, representa la forma de la matriz aumentada [Ab]

fprintf('\nLa Matriz C, que corresponte a la matriz aumentada [Ab] es =

\n');
disp(C); % la funcion disp nos permite imprimir una variable en el
espacio de trabajo

if n==m
for k=1:(n-1)%instruccion iterativa que permite repetir pasos un
numero
%determinado de veces
fprintf('\n ETAPA %g=\n\n',k)
fprintf('\nLa matriz correspondiente a esta etapa antes del
proceso:\n')
disp(C)
fprintf('\nLos Multiplicadores correpondientes a esta etapa
son:\n')
for i=(k+1):n
m(i,k)=C(i,k)/C(k,k); %formula para hallar los
multiplicadores
fprintf('\nm(%g,%g)=',i,k)
disp(m(i,k));
for j=k:(n+1)
 C(i,j)= C(i,j) - m(i,k)*C(k,j); %formula de la nueva fila
end
end
fprintf('\nLa matriz correspondiente a esta etapa despues del
proceso:\n')
disp(C)
end
for i=n:-1:1
suma=0;
for p=(i+1):n
suma = suma + C(i,p)*X(p);
end
X(i)=(C(i,n+1)-suma)/C(i,i);
%formula de la susticion regresiva y solucion de las variables
end
else %funcion asignada del if, en caso de que este sea falso
fprintf('\nERROR: La matriz NO es cuadrada\n');
end
fprintf('\n\n\nSOLUCIN:\n');
fprintf('\n\nLa matriz Ab final:\n');
disp(C)
fprintf('\n\nLa solucion de X1 hasta Xn es:\n');
%a continuacion de utiliza una instruccion for, para mostrar el usuario,
%los resultados de una manera mas ordena
for i=1:n
Xi=X(1,i);
fprintf('\nX%g=',i)
disp(Xi);
end

En donde luego de Introducir la Matriz A y el Vector B, tenemos:

Ingrese la matriz A = [1 -1 -4;2 3 4;3 5 7]

Ingrese el vector b, correspondite a los terminos independientes b= [1;24;38]

La Matriz C, que corresponte a la matriz aumentada [Ab] es =

1 -1 -4 1
2 3 4 24
3 5 7 38

ETAPA 1=
La matriz correspondiente a esta etapa antes del proceso:
1 -1 -4 1
2 3 4 24
3 5 7 38
Los Multiplicadores correpondientes a esta etapa son:

m(2,1)= 2
m(3,1)= 3
La matriz correspondiente a esta etapa despues del proceso:
1 -1 -4 1
0 5 12 22
0 8 19 35

ETAPA 2=
La matriz correspondiente a esta etapa antes del proceso:
1 -1 -4 1
0 5 12 22
0 8 19 35
Los Multiplicadores correpondientes a esta etapa son:
m(3,2)= 1.600000000000000
La matriz correspondiente a esta etapa despues del proceso:
1.000000000000000 -1.000000000000000 -4.000000000000000 1.000000000000000
0 5.000000000000000 12.000000000000000 22.000000000000000
0 0 -0.200000000000003 -0.200000000000003
SOLUCIN:
La matriz Ab final:
1.000000000000000 -1.000000000000000 -4.000000000000000 1.000000000000000
0 5.000000000000000 12.000000000000000 22.000000000000000
0 0 -0.200000000000003 -0.200000000000003
La solucion de X1 hasta Xn es:
X1= 7
X2= 2
X3= 1

3. Metodo Eliminacion Gaussiana:

Tenemos el siguiente programa en MatLab:

function y = eliminacion(A,B)
[n n]=size(A);
A=[A';B']';
x=zeros(n,1);
for p=1:n
for k=[1:p-1,p+1:n];
m=-A(k,p)/A(p,p);
A(k,:)=A(k,:)+m*A(p,:)
end
end
x=A(:,n+1)./diag(A)

En donde luego de ingresar la Matiz A y el vector B, tenemos:

>> A=[1 -1 -4;2 3 4;3 5 7]

A =

1 -1 -4
2 3 4
3 5 7

>> B=[1;24;38]

B =

1
24
38
Solucion:

>> Eliminacion_Gaussiana(A, B)
A =

1 -1 -4 1
0 5 12 22
3 5 7 38

A =

1 -1 -4 1
0 5 12 22
0 8 19 35

A =

1.000000000000000 0 -1.600000000000000 5.400000000000000

0 5.000000000000000 12.000000000000000 22.000000000000000
0 8.000000000000000 19.000000000000000 35.000000000000000

A =

1.000000000000000 0 -1.600000000000000 5.400000000000000

0 5.000000000000000 12.000000000000000 22.000000000000000
0 0 -0.200000000000003 -0.200000000000003

A =

1.000000000000000 0 0 7.000000000000000
0 5.000000000000000 12.000000000000000 22.000000000000000
0 0 -0.200000000000003 -0.200000000000003

A =

1.000000000000000 0 0 7.000000000000000
0 5.000000000000000 0 10.000000000000000
0 0 -0.200000000000003 -0.200000000000003

x =

7
2
1