ANALISIS NUMERICO COMPUTACIONAL

ELIMINACION GAUSSIANA CON PIVOTEO PARCIAL (SOLUCION POR ETAPAS)

fprintf(' ELIMINACION GAUSSIANA CON PIVOTEO PARCIAL (SOLUCION 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 tamaño 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 %compara el numero de columnas y filas, para observar si son iguales

for k=1:(n-1)

fprintf('\n ETAPA %g=\n\n',k)

mayor=0; %asigna como cero el numero mayor de la fila

filam=k; %asigna la fila k como la columna que tiene el numero mayor

for p=k:n

if mayor<abs(C(p,k)) %se busca el numero mayor en la fila K;

mayor=abs(C(p,k));%cambio de mayor

filam=p; %cambio de fila

end

end

if mayor ==0

fprintf('\nEl sistema tiene infinitas soluciones\n')

break %se interrumpe el programa con la instruccion break, ya que

%si mayor=o, mas adelante se obtiene una division por

%cero

else

ANALISIS NUMERICO COMPUTACIONAL

if filam ~= k

for j=1:(n+1)

aux=C(k,j); %para poder intercambiar las filas, utilizamos una

%variable auxiliar

C(k,j)=C(filam,j);

C(filam,j)=aux;

end

end

end

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 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 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

ANALISIS NUMERICO COMPUTACIONAL

else %funcion asignada del if, en caso de que este sea falso

fprintf('\nERROR: La matriz NO es cuadrada\n');

end

fprintf('\n\n SOLUCION:\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 ordenada

for i=1:n

Xi=X(1,i);

fprintf('\nX%g=',i)

disp(Xi);

end

MATLAB PIVOTEO PARCIAL ESCALONADO

%-Modulo: GPivParEsc

%-Autor: Aitor Calderon Martinez {aitorc@navegalia.com}

%-Proposito: Calculo de ecuaciones lineales por el metodo de Gauss con

% pivoteo parcial escalonado

%-Funciones: -GPivParEsc (funcion principal)

% -IntercambioF (funcion declarada localmente)

%-Comentarios: El codigo fuente esta comentado, lo unico a resaltar es el uso

% de la funcion 'cputime', cuya funcion en este modulo es la obtencion del

% tiempo transcurrido durante la ejecucion del programa {timepo_inicial -

% tiempo_final.}

function R = GPivParEsc(A,B)

t = cputime; %Obtenemos el los segundos actuales

ANALISIS NUMERICO COMPUTACIONAL

format rat; %Pedimos al programa que use fracciones en vez de numeros {con esto el error sera menor}

if ((nargin < 2) | (nargin > 2)) %si el numero de argumentos no es el pedido...

fprintf('El numero de argumentos difiere del necesario.\n');

A = input('Por favor escriba a continuacion la matriz de incognitas A:\n');

B = input('A continuacion escriba la matriz de elementos independientes B:\n');

end

[F,C] = size(A); %Obtenemos el orden de la matriz -> F = numero de filas C = numero de columnas

[FB,CB] = size(B); %Obtenemos el orden de la matriz -> FB = numero de filas CB = numero de columnas

if ((F ~= C) | (CB > 1) | (FB ~= F))

fprintf('Error: El orden de la matriz A y/o la matriz B, no es/son el/los correcto/s. \n Por favor reviselo');

return; %Mostramos un mensaje y alimos

end

S = [0;0]; %La matriz S

AB = [A,B]; %La matriz resultado de concatenar A y B

for i = 1:F %Para cada fila...

M = abs(A(i,1)); %Tomamos el primer elemento

for j = 2:C %Para cada elemento de la fila... {el primero ya lo hemos tomado}

if abs(A(i,j)) > M %Si el elemento actual es mayor que el maximo registrado...

M = abs(A(i,j)); %Este pasa a ser el maximo

end

end

S(i) = M; %El elemento de la fila i de S es el maximo registrado

if S(i) == 0 %Si algun elemento de S es 0...

fprintf('No existe solucion unica para el sistema. Finalizado SIN exito'); %No existe solucion unica

return; %Paramos el proceso de creacion de la matriz S y salimos

end

ANALISIS NUMERICO COMPUTACIONAL

end

for i = 1:(C-1)% Para cada columna...

for q = i:(F)%Ordenamos la columna t. q. a(1,i)/S(1)<(2,i)/S(2)<...<a(q,i)/S(q)

MaxF = q; %La fila con el maximo {asignamos el primero al inicio}

Max = abs(AB(q,i))/S(q); %El maximo {asignamos el primero al inicio}

for j = (q+1):F %Recorremos la columna en busca de otro posible maximo

if AB(j,i)/S(j) > Max %Si el elemento actual es mayor que el maximo registrado..

Max = abs(AB(j,i))/S(j); %Asignamos el valor de este maximo

MaxF = j; %Asignamos la nueva fila maxima a su variable

end

end

if (MaxF ~= q) %Si el maximo no se encuantra en la fila de inicio

AB = IntercambioF(AB,MaxF,q); %Intercambiamos la fila de AB para q coincida

S = IntercambioF(S,MaxF,q); % Tambien se debe cambiar en S, puesto q el orden ha cambiado

end

end %Columna ya ordenada

if (AB(i,i) == 0) %El elemento de la diagonal NO puede ser 0, si es cero no existe solucion unica

fprintf('No existe solucion unica para el sistema. Finalizado SIN exito'); %No existe solucion unica

return;% Salimos

end

for j = (i+1):F %Modificamos las filas para hacer 0's

m = (AB(j,i)/AB(i,i)); %m sera el multiplicando, es necesario declararlo

%antes de intercambiar las filas porque el valor de los elementos

%de las mismas variara cuando hagamos 0's, y por consiguiente el

%valor de m

for q = 1:(C+1) %Para cada elemento de la fila...

AB(j,q) = AB(j,q) - m*AB(i,q); %Realizamos el cambio

end

ANALISIS NUMERICO COMPUTACIONAL

end

end

for i = 1:F

if (AB(i,i) == 0) %Ningun elemento de la diagonal NO puede ser 0, si es cero no existe solucion unica

fprintf('No existe solucion unica para el sistema. Finalizado SIN exito'); %No existe solucion unica

return; %Salimos

end

end

X = [0;0]; %matriz con los resultados

X(F) = AB(F,F+1)/AB(F,F); %Asignamos el ultimo elemento

for i = (F-1):-1:1 %Y vamos calculando los demas

Sum = 0; %inicializacion de la variable Sum {para calcular el sumatorio}

for j = (i+1):F %bucle para el sumatorio, para cada fila...

Sum = Sum + AB(i,j)*X(j); %Calculamos el resultado actual y lo añadimos al conocido

end

X(i) = (AB(i,F+1)-Sum)/AB(i,i); %Obtenemos X(i)

end

fprintf('Resolucion del sistema concluida en: %d segundos. El resultado: \n',(cputime - t));

R = X; %El resultado es X

%A continuacion se encuentra la funcion IntercambioF, cuya funcion es

%intercambiar filas de una matriz. En principio esta operacion se puede

%realizar de dos formas, la expuesta y sabiendo q A(n,:) devuelve la fila

%completa n de la matriz A. Yo he escogido la primera forma porque es un

%metodo mas grafico y menos bastracto.

function Z = IntercambioF(V,f1,f2) %Funcion interna para intercambiar filas

[FV,CV] = size(V); %Obtenemos el numero de filas y columnas {F y C respectibamente}

CV1 = 0; %Aqui se un valor

ANALISIS NUMERICO COMPUTACIONAL

for n = 1:CV %Bucle para recorrer las columnas

CV1 = V(f1,n); %CV1 = fila 1

V(f1,n) = V(f2,n); %Asignamos a

V(f2,n) = CV1; %Asignamos a la fila nº f2 la fila CV1

end

Z = V; %el resultado es la nueva matriz V

ANALISIS NUMERICO COMPUTACIONAL