Índice de contenido
OBJETIVO.................................................................................................................................................3 INTRODUCCIÓN......................................................................................................................................3 DESARROLLO..........................................................................................................................................5 Código en Matlab..................................................................................................................................5 Código en C...........................................................................................................................................6 DIAGRAMA DE FLUJO DE CÓDIGO EN MATLAB............................................................................7 DIAGRAMA DE FLUJO DE CÓDIGO EN C.......................................................................................10 CASOS DE ESTUDIO.............................................................................................................................10 CONCLUSIÓN.........................................................................................................................................11 PRÁCTICA 2. MÉTODO DE ELIMINACIÓN DE GAUSS NORMALIZADO.......................................12 OBJETIVO...............................................................................................................................................12 INTRODUCCIÓN....................................................................................................................................12 DESARROLLO........................................................................................................................................14 Código en Matlab.....................................................................................................................................14 Código en C.........................................................................................................................................15 DIAGRAMA DE FLUJO DE CÓDIGO EN MATLAB....................................................................18 DIAGRAMA DE FLUJO DE CÓDIGO EN C...................................................................................19 CASOS DE ESTUDIO.............................................................................................................................20 CONCLUSIÓN........................................................................................................................................20 PRÁCTICA 3. MÉTODO DE GAUSS – JORDAN....................................................................................21 INTRODUCCIÓN....................................................................................................................................21 DESARROLLO........................................................................................................................................23 Código en matlab.................................................................................................................................23 Código en C.........................................................................................................................................23 DIAGRAMA DE FLUJO DE CÓDIGO EN MATLAB.....................................................................25 DIAGRAMA DE FLUJO DE CÓDIGO EN C...................................................................................26 PRÁCTICA 4. INVERSIÓN DE MATRICES...................................................................................28 INTRODUCCIÓN....................................................................................................................................28 DESARROLLO........................................................................................................................................30 Código en C.........................................................................................................................................30 Código en Matlab................................................................................................................................31 CASO DE ESTUDIO...................................................................................................................................35 CONCLUSIÓN........................................................................................................................................36 PRÁCTICA 5. FACTORIZACIÓN LU........................................................................................................37 INTRODUCCIÓN....................................................................................................................................37 DESARROLLO........................................................................................................................................40 Código en C.........................................................................................................................................40 CASOS DE ESTUDIO..................................................................................................................................43 CONCLUSIÓN........................................................................................................................................43
1
PRÁCTICA 1. MÉTODO DE ELIMINACIÓN DE GAUSS SIN NORMALIZAR. OBJETIVO. Se realizará a través de Matlab un programa para la resolución de un sistema de ecuaciones lineales a través por el método de eliminación de Gauss sin normalizar.
INTRODUCCIÓN. En el método todo para ara la solu soluc ción ión de ecuacio acion nes
line ineale ales sim simultán ltáne eas
denominado como eliminación de Gauss se eliminan las incógnitas mediante la comb combin inac ació ión n de las las ecu ecuacio acione nes s media ediant nte e el proc proces eso o de elim elimin inac ació ión n que que esquematizó Gauss. Gauss. Utilizando el método de Gauss, un conjunto de n ecuaciones con n incógnitas se reduce a un sistema triangular equivalente, equivalente , que a su vez se resuelve de fácilmente por "sustitución inversa"; un procedimiento simple que se ilustrará con la presentación siguiente. Sabiendo:
a11 X 1 + a 12 X2 + a13 X 3 +... + a 1n X n =C1
a 21 X 1 + a 22 X 2 + a 23 X 3 +... + a 2n X n
=C2
( a ) ( b )
( 2 )
...
a n1 X 1 + a n2 X 2 + a n3 X 3 + ... + a nn X n
=Cn
( c )
El esqu esquem ema a de Gaus Gauss s empi empiez eza a redu reduci cien endo do un conj conjun unto to de ecua ecuaci cion ones es simultáneas a un sistema triangular equivalente como:
2
( 6 )
en el cual los superíndices indican los nuevos coeficientes que se forman en el proceso de reducción. La reducción real se logra de la siguiente manera:
1. Para obtener las modificaciones se multiplica los coeficientes de la ecuación. (7) por el coeficiente de X de X 1 de la segunda ecuación (2), al producto producto de ellas se divide entre el coeficiente pivote(a 11) y la ecuación que resulta se resta de la misma, eliminando así X así X 1.. Entonces se repite el mismo proceso para las demás ecuaciones hasta adoptar la forma:
( 8 )
La ecuación usada para eliminar las incógnitas en las ecuaciones que la siguen se denomina Ecuación Pivote. Pivote. En la ecuación pivote, el coeficiente de la incógnita que se va a eliminar de las ecuaciones que la siguen se denomina el Coeficiente Pivote (a11 en los pasos previos). previos).
2. Siguiendo los pasos anteriores, la segunda ecuación (8) se convierte en la ecuación pivote, pivote, y los pasos de la parte 1 se repiten para eliminar eliminar X X 2 de todas las ecuaciones que siguen a esta ecuación pivote. Esta reducción nos conduce a:
3
( 9 )
3. A continuación se utiliza la tercer ecuación (9) como ecuación pivote, y se usa el procedimiento descrito para eliminar X eliminar X 3 de todas las ecuaciones ecuaciones que siguen a la tercer ecuación (9). Este procedimiento, utilizando diferentes ecuaciones pivote pivote,, se contin continúa úa hasta hasta que que el conjun conjunto to origin original al de ecuac ecuacion iones es ha sido sido reducido a un conjunto triangular tal como se muestra en la ecuación (6).
4. Una vez obtenido el conjunto triangular de ecuaciones, la última ecuación de este conjunto conjunto equivale equivalente nte suminist suministra ra directa directamen mente te el valor valor de X n dividido entre su coeficiente. Este valor se sustituye entonces en la antepenúltima ecuación del conjunto triangular para obtener un valor de X n-1 n-1, que a su vez se util utiliz iza a junt junto o con con el valo valorr de X n en la penú penúlti ltima ma ecuaci ecuación ón del del conjun conjunto to trian triangu gular lar para para obten obtener er un valor valor X n-2 así suce sucesi siva vam mente ente.. Este ste es el n-2 y así procedimiento de sustitución inversa al que nos referimos previamente.
DESARROLLO. Código en Matlab para Eliminación de Gauss sin normalizar. normalizar. %Método de eliminacion gauss
%moverse en los renglones
clc clear all
for i=k+1:r %moverse en las columnas
A=[40 -10 -30 10;-10 30 -5 0;-30 -5 65 0]
for j=c:-1:k
%Midiendo dimensiones de matriz A
A(i,j)=A(i,j)-((A(i,k)/A(k,k))*A(k,j));
[r,c]=size(A)
end
%Eliminación hacia adelante
end
%para mover el pivote
end
for k=1:c
A
4
%sustitución hacia atrás
sum=sum+A(i,j)*x(j);
%asignando el valor de Xn x(r)=A(r,c)/A(r,r);
end %obteniendo Xn
%moverse en renglones
x(i)=(A(i,c)-sum)/A(i,i);
for i=r-1:-1:1
end
%inicializando sum en cero
%mostrando Xn
sum=0;
x
for j=i+1:r %haciendo la sutitución para An-1nXn-1
Código en C para Eliminación de Gauss sin normalizar . for(j=m-1;j>=0;j--){ #include
//haciendo las modificaciones para gauss
#include
sin normalizar
int main(){
A[i][j]=A[i][j]-((A[i][k]/A[k][k])*A[k][j]);
//declarando variables para contadores
}}}
int k,i,j,m,n;
//para imprimir la matriz resultante
//inicializando dimensiones
printf("Metodo:
n=3;
normalizar\n\n");
m=4;
for(i=0;i
//inicializando matriz
for(j=0;j
float
A[3][4]={{40,-10,-30,10},{-10,30,-printf("%f\t",A[i][j]);
5,0},{-30,-5,65,0}};
}
//mover el pivote
printf("\n");
for(k=0;k<=n-1;k++){
}
//moverse en el renglon
return 0;
for(i=k+1;i<=n-1;i++){
}
//moverse en la columna
5
Gauss
sin
DIAGRAMA
DE
NORMALIZAR
6
FLUJO DE
CÓDIGO
EN
MATLAB
PARA
GAUSS
SIN
DIAGRAMA
7
DE
FLUJO
DE
CÓDIGO
EN
C
8
PARA GAUSS SIN NORMALIZAR
CASOS DE ESTUDIO. Del circuito:
Se obtiene:
9
donde
Dado otro circuito
10
el
resultado
es
se obtiene:
La solución es:
CONCLUSIÓN. Este método es de gran importancia ya que es la base para los demás métodos que se verán a lo largo del curso, por lo que el aprendérselo es vital para el entendimiento de los demás métodos.
PRÁCTICA 2. MÉTODO DE ELIMINACIÓN DE GAUSS NORMALIZADO. 11
OBJETIVO. Se realizará a través de Matlab un programa para la resolución de un sistema de ecuaciones lineales a través por el método de eliminación de Gauss sin normalizar.
INTRODUCCIÓN. En el método para la solución de ecuaciones
lineales simultáneas
denominado como eliminación de Gauss se eliminan las incógnitas mediante la combinación de las ecuaciones mediante el proceso de eliminación que esquematizó Gauss. Utilizando el método de Gauss, un conjunto de n ecuaciones con n incógnitas se reduce a un sistema triangular equivalente, que a su vez se resuelve de fácilmente por "sustitución inversa"; un procedimiento simple que se ilustrará con la presentación siguiente. Sabiendo:
a11 X 1 + a 12 X2 + a13 X 3 +... + a 1n X n =C1
a 21 X 1 + a 22 X 2 + a 23 X 3 +... + a 2n X n
=C2
( a ) ( b )
( 2 )
...
a n1 X 1 + a n2 X 2 + a n3 X 3 + ... + a nn X n
=Cn
( c )
El esquema de Gauss empieza reduciendo un conjunto de ecuaciones simultáneas a un sistema triangular equivalente como:
12
( 6 )
en el cual los superíndices indican los nuevos coeficientes que se forman en el proceso de reducción. La reducción real se logra de la siguiente manera:
5. La primera ecuación se divide entre el coeficiente de X 1 en esa ecuación para obtener(a este paso se le denomina normalización): ( 7 ) Entonces para obtener las modificaciones se multiplica los coeficientes de la ecuación. (7) por el coeficiente de X 1 de la segunda ecuación (2) y la ecuación que resulta se resta de la misma, eliminando así X 1. La ec. (7) se multiplica entonces por el coeficiente de X 1 de la tercera ecuación (2), y la ecuación resultante se resta de la misma para eliminar X 1 de esa ecuación. En forma similar, X se elimina de todas las ecuaciones del conjunto excepto la primera, de forma que el conjunto adopta la forma:
( 8 )
La ecuación usada para eliminar las incógnitas en las ecuaciones que la siguen se denomina Ecuación Pivote. En la ecuación pivote, el coeficiente de la incógnita que se va a eliminar de las ecuaciones que la siguen se denomina
13
el Coeficiente Pivote (a11 en los pasos previos).
6. Siguiendo los pasos anteriores, la segunda ecuación (8) se convierte en la ecuación pivote, y los pasos de la parte 1 se repiten para eliminar X 2 de todas las ecuaciones que siguen a esta ecuación pivote. Esta reducción nos conduce a:
( 9 )
7. A continuación se utiliza la tercer ecuación (9) como ecuación pivote, y se usa el procedimiento descrito para eliminar X 3 de todas las ecuaciones que siguen a la tercer ecuación (9). Este procedimiento, utilizando diferentes ecuaciones pivote, se continúa hasta que el conjunto original de ecuaciones ha sido reducido a un conjunto triangular tal como se muestra en la ecuación (6).
8. Una vez obtenido el conjunto triangular de ecuaciones, la última ecuación de este conjunto equivalente suministra directamente el valor de X n. Este valor se sustituye entonces en la antepenúltima ecuación del conjunto triangular para obtener un valor de X n-1, que a su vez se utiliza junto con el valor de X n en la penúltima ecuación del conjunto triangular para obtener un valor X n-2 y así sucesivamente. Este es el procedimiento de sustitución inversa al que nos referimos previamente.
DESARROLLO.
Código en Matlab para Eliminación de Gauss normalizado. %Método de eliminacion gauss clc
14
clear all A=[40 -10 -30 10;-10 30 -5 0;-30 -5 65 0]
[r,c]=size(A) %tomar dimensiones de la matriz %Eliminación hacia adelante for k=1:c for i=k+1:r for j=c:-1:k %normalizando ecuacion pivote A(k,j)=A(k,j)/A(k,k); %haciendo la modificaciones A(i,j)=A(i,j)-(A(i,k)*A(k,j)); end end end %sacando una copia copia=A(r,r); for k=r:1:c %para terminar la normalización A(r,k)=A(r,k)/copia;
end A %sustitución hacia atrás %asignar valor en Xn x(r)=A(r,c); for i=r-1:-1:1 sum=0; for j=i+1:r %hace sustitución sum=sum+A(i,j)*x(j); end asigna el valor en Xi x(i)=(A(i,c)-sum)/A(i,i); end muestra matriz de incógnitas x
Código en C para Eliminación de Gauss normalizado. #include for(i=0;i for(j=0;j0;i--){ for(i=k+1;i<=n-1;i++){ sum=0; for(j=m-1;j>=0;j--){ for(j=i+1;j=n-1){ for(i=0;i<=n-1;i++){ //terminando normalización printf("%f\t",x[i]); A[n-1][k]=A[n-1][k]/A[n-1][n-1]; } k--; return 0; } }
15
16
17
DIAGRAMA DE FLUJO DE CÓDIGO EN MATLAB PARA GAUSS NORMALIZADO DIAGRAMA DE FLUJO DE CÓDIGO EN C PARA GAUSS NORMALIZADO
18
CASOS DE ESTUDIO. Dado el siguiente circuito
Obtener:
Solución.
19
CONCLUSIÓN. El método que más se me facilita es el de Gauss normalizado ya que es en donde menos operaciones haces, además de que para hacer el programa que realiza el método no se necesitan tantas instrucciones como en las otras formas de resolver ecuaciones.
PRÁCTICA 3. MÉTODO DE GAUSS – JORDAN OBJETIVO. Por medio de la programación en Matlab, desarrollar un programa capaz de resolver un sistema de ecuaciones lineales por medio del método de Gauss-Jordan.
INTRODUCCIÓN Este método, que constituye una variación del método de eliminación de Gauss, permite resolver hasta 15 o 20 ecuaciones simultáneas, con 8 o 10 dígitos significativos en las operaciones aritméticas de la computadora. Este procedimiento se distingue del método Gaussiano en que cuando se elimina una incógnita, se elimina de todas las ecuaciones restantes, es decir, las que preceden a la ecuación pivote así como de las que la siguen.
20
Para una mejor comprensión, la explicación del método se realizará por medio de un sistema de ecuaciones. 3.0 X1-0.1X2-0.2X3 = 7.8500 0.1 X1+7.0X2-0.3 X3 = - 19.3 0.3 X1-0.2X2+10X3 = 71.4000 Primero expresemos los coeficientes y el vector de términos independientes como una matriz aumentada.
Se normaliza el primer renglón dividiendo entre el coeficiente pivote(a 11=3) para obtener:
El término X 1 se puede eliminar del segundo renglón restando 0.1 veces el primero del segundo renglón. De una manera similar, restando 0.3 veces el primero del tercer renglón se elimina el término con X 1 del tercer renglón.
En seguida, se normaliza el segundo renglón dividiendo entre el segundo pivote (7.00333):
21
Reduciendo los términos en X 2 de la primera y la tercera ecuación se obtiene:
El tercer renglón se normaliza dividiéndolo entre el 10.010:
Finalmente, los términos con X 3 se pueden reducir de la primera y segunda ecuación para obtener:
Nótese que no se necesita sustitución hacia atrás para obtener la solución. Aunque los métodos de Gauss-Jordan y de eliminación de Gauss pueden parecer casi idénticos, el primero requiere aproximadamente 50% menos operaciones. Por lo tanto, la eliminación gaussiana es el método simple por excelencia en la obtención de soluciones exactas a las ecuaciones lineales simultáneas. Una de las principales razones para incluir el método de Gauss-Jordan, es la de proporcionar un método directo para obtener la matriz inversa.
22
DESARROLLO. Código en matlab para el métodoend Gauss Jordan.
%Haciendo Jordan
%Método Gauss-Jordan
%haciendo ceros del otro lado de la matriz
clc
for k=1:c
clear all
for i=k+1:r
%inicializando matriz
for j=c:-1:k
A=[40 -10 -30 10;-10 30 -5 0;-30 -5 65 0]
A(k,j)=(A(k,j)-(A(k,i)*A(i,j)));
%midiendo matriz
end
[r,c]=size(A)
end
clc
end
A
A
%Haciendo Gauss %para el pivote for k=1:r %para los renglones for i=k+1:r %para las columnas for j=c:-1:k %normalizando la ecuación pivote A(k,j)=A(k,j)/A(k,k);
Código en C para el método Gauss Jordan. #include #include int main(){ //declarando contadores
int k,i,j,m,n; %haciendo modificaciones dejando ceros //inicializando dimensiones abajo n=3; A(i,j)=A(i,j)-(A(i,k)*A(k,j)); m=4; end //inicializando matriz end float A[3][4]={{40,-10,-30,10},{-10,30,end 5,0},{-30,-5,65,0}}; acabando de normalizar for(k=0;k<=n-1;k++){ for k=c:-1:r for(i=k+1;i<=n-1;i++){ A(r,k)=A(r,k)/A(r,r);
23
for(j=m-1;j>=0;j--){
printf("\n"); }
//normalizando
for(k=0;k
A[k][j]=A[k][j]/A[k][k];
for(i=k+1;i
//modificando matriz y haciendo ceros
for(j=m-1;j>=k;j--){
A[i][j]=A[i][j]-(A[i][k]*A[k][j]);
//haciendo ceros del otro lado de la matriz
}}}
A[k][j]=A[k][j]-(A[k][i]*A[i][j]);
//acabando de normalizar
}}}
k=m-1;
printf("\n");
while(k>=n-1){
//mostrando la matriz Gauss-Jordan
A[n-1][k]=A[n-1][k]/A[n-1][n-1];
printf("Haciendo Jordan\n\n");
k--; }
for(i=0;i
//imprimiendo la parte de Gauss
for(j=0;j
printf("Haciendo Gauss\n\n");
printf("%f\t",A[i][j]); }
for(i=0;i
printf("\n"); }
for(j=0;j
return 0; }
printf("%f\t",A[i][j]); }
DIAGRAMA DE FLUJO DE CÓDIGO EN MATLAB PARA GAUSS-JORDAN
24
25
DIAGRAMA DE FLUJO DE CÓDIGO EN C PARA GAUSS-JORDAN
26
CASOS DE ESTUDIO. Dado el siguiente circuito.
27
Su representación de forma de un sistema de ecuaciones lineales
Se resuelve a través de Gauss-Jordan
28
CONCLUSIÓN El sistema expuesto anteriormente presenta el mismo principio que el de eliminación de Gauss, sin embargo al hacer el doble de las operaciones es más trabajoso resolver los sistemas de ecuaciones, así que prefiero hacerlo por el método de eliminación gaussiana.
PRÁCTICA 4. INVERSIÓN DE MATRICES. OBJETIVO. Por medio de la programación en Matlab, desarrollar un programa capaz de resolver un sistema de ecuaciones lineales obteniendo la inversa de una matriz por medio de Gauss-Jordan y multiplicando la inversa por la matriz de resultados.
INTRODUCCIÓN Sea A una matriz cuadrada no singular , es decir, que su determinante sea diferente de cero,
. Por definición de matriz inversa, se tiene que
es la inversa de A si: (1 Haciendo
29
3) y sustituyendo en la ecuación anterior, se obtiene
A
X
(1
=I 4) Puede considerarse que esta ecuación matricial representa un sistema de ecuaciones
simultáneas,
en
donde
no
hay
un
solo vector de términos
independientes sino n, los n vectores básicos que forman la matriz unitaria I. Además, no existe un solo vector de incógnitas, sino n, los que corresponden a cada columna de la matriz unitaria. Por lo anterior, es posible determinar la inversa de una matriz con el método de Gauss-Jordan de eliminación completa. Para lograrlo, bastará con aplicar las operaciones elementales sobre los renglones de la matriz ampliada (A, I) de manera de transformar A en I. Cuando se haya hecho, se obtendrá la matriz ampliada
, con lo que se tendrá la inversa buscada.
EJEMPLO Invertir la matriz
Auméntese la matriz de coeficientes con una matriz identidad
Usando
a
11
como pivote, el renglón 1 se normaliza y se usa para eliminar a X 1
de los otros renglones.
30
En seguida, se usa
a
Finalmente, se usa
a
22
33
como pivote y X 2 se elimina de los otros renglones.
como pivote y X 3 se elimina de los renglones restantes:
Por lo tanto, la inversa es:
Se puede resolver un sistema de ecuaciones con la inversa de la matriz de coeficientes, de la siguiente manera:
donde C es el vector de términos independientes.
DESARROLLO. 31
Código en C para la inversión de B[k][j]=B[k][j]/B[k][k]; matrices. B[i][j]=B[i][j]-(B[i][k]*B[k][j]); #include }}} int main(){
k=m-1;
//declarando variables
while(k>=n-1){
int k,i,j,m,n;
B[n-1][k]=B[n-1][k]/B[n-1][n-1];
//inicializando dimensiones
k--;
n=3;
}
m=4;
//Haciendo Jordan
//inicializando matriz
for(k=0;k=k;j--){ //declarar matriz B=(A, I) B[k][j]=B[k][j]-(B[k][i]*B[i][j]); float B[3][6]; //modificar m para manipular B m=6; for(i=0;in) B[i][j]=0; else B[i][j]=A[i][j]; } } //Haciendo Gauss for(k=0;k<=n-1;k++){ for(i=k+1;i<=n-1;i++){ for(j=m-1;j>=0;j--){
32
}}} //declara matriz de resultados float x[n]; for(i=0;i
//mostrando matriz de resultados
for j=c:-1:k
for(i=0;i
A(k,j)=A(k,j)/A(k,k);
printf("%f\t",x[i]);
A(i,j)=A(i,j)-(A(i,k)*A(k,j));
return 0;
end
}
end
Código en Matlab para la inversión end de matrices. for k=c:-1:r %Método Gauss-Jordan A(r,k)=A(r,k)/A(r,r); clc
end
clear all
%Haciendo Jordan
A=[40 -10 -30 10;-10 30 -5 0;-30 -5 65 0] for k=1:c [r,c]=size(A) for i=k+1:r for i=1:r
for j=c:-1:k
for j=r+1:2*r
A(k,j)=(A(k,j)-(A(k,i)*A(i,j)));
if (j-i==r)
end
A(i,j)=1; else A(i,j)=0;
end end for i=1:r
end
for j=1:r
end
B(i,j)=A(i,j+r);
end
end
[r,c]=size(A)
end
clc
B
A %Haciendo Gauss for k=1:r for i=k+1:r
33
34
35
CASO DE ESTUDIO.
36
Para nodo 1.
Para nodo 2.
Para nodo 3.
en forma matricial tenemos:
poniendo el comando V=inv(Y)*I entonces la matriz de incógnitas se resuelve como: V=404.2857 350.0000 412.8571
37
CONCLUSIÓN. Para obtener la inversa de una matriz no tiene una gran dificultad, solamente es el método Gauss-Jordan anexándole la matriz identidad, solamente la cantidad de cálculos aumenta considerablemente.
38
PRÁCTICA 5. FACTORIZACIÓN LU. OBJETIVO. Por medio de la programación en Matlab, desarrollar un programa capaz de resolver un sistema de ecuaciones lineales por medio del método de factorización LU.
INTRODUCCIÓN La factorización LU de una matriz es una factorización que resume el proceso de eliminación gaussiana aplicado a la matriz y que es conveniente en términos del número total de operaciones de punto flotante cuando se desea calcular la inversa de una matriz o cuando se resolver una serie de sistemas de ecuaciones con una ́
misma matriz de coeficientes. Suponga que la matriz A es una matriz m × n se puede escribir como el producto de dos matrices: A = LU donde L es una matriz triangular inferior m × m y U es una matriz escalonada m × n. Entonces para resolver el sistema: A x = b, escribimos A x = (L U) x = L (U x) . Una posible estrategia de solución consiste en tomar y = U x “y” resolver para y: o L y = b. Como la matriz L es triangular superior este sistema puede resolverse mediante sustitución hacia abajo. Una vez con los valores encontrados de y, las incógnitas al sistema inicial se resuelve despejando x de U x = y. Nuevamente, como U es escalonada, este sistema puede resolverse en caso de tener solución mediante sustitución, lo cual es sencillo. Estas observaciones nos dan la pauta para ver la conveniencia de una factorización como la anterior, es decir factorizar A como el producto de una matriz L triangular superior, por otra U la
39
cual es escalonada. Esta factorización se llama usualmente descomposición LU.
Obtención de la factorización LU Ejemplo: determine la factorización LU de
La idea del método es ir acumulando las inversas de las operaciones hechas sobre los renglones la matriz para irla transformando en una matriz escalonada. Y más que propiamente las inversas de las operaciones sobre los renglones, las matrices elementales involucradas. Así por ejemplo el primer cálculo que se realiza es hacer un cero debajo de el elemento (1, 1) que es el elemento 2, para ello debemos realizar la operación R 2 elemental la matriz:
Así la situación está:
40
←
R2 + 3R1, esta operación tiene como matriz
En el siguiente paso del proceso de eliminación es R 3
←
R3 −2R1 , esta
operación tiene como matriz elemental la matriz:
Así la situación está:
En el siguiente paso del proceso de eliminación es R4 operación tiene como matriz elemental la matriz:
Así la situación está:
41
←
R4 + R1 , esta
Observamos que el hipotético caso de que en E3 E2 E1 A = B3 La matriz B3 ya fuera escalonada, es decir la U buscada, entonces: A = E1 −1 E2 −1 E3 −1 U Lo cual indica que lo que debemos acumular son las inversas de las matrices elementales utilizadas. La forma sistemática de ir acumulando las inversas de las E is es ir construyendo la matriz L:
Así en el avance de la conversión a escalonada de A:
En este caso la matriz U está en la forma escalonada y por consiguiente el proceso se detiene haciendo cero aquellos valores desconocidos. Por consiguiente una factorización de A será:
42
DESARROLLO.
A[i][j]=A[i][j]-((A[i][k]/A[k][k])*A[k][j]); Código en C para LU. }}} #include for(i=0;i=0;j--){ } if((j==n-1)&&(i==k+1)){ float y[n]; for(w=0;w=k) y[0]=L[0][n]; L[w][k]=A[w][k]/A[k][k]; for(i=1;i
43
printf("y= \n"); for(i=0;i=0;i--){ sum=0; for(j=i+1;j<=n-1;j++)
44
//para obtener los valores de la sustitución sum=sum+A[i][j]*x[j]; //se introduce el valor de Xn en la matriz de resultados x[i]=(A[i][m-1]-sum)/A[i][i]; } printf("\nLos valores de X's son\n\n"); //se imprime la matriz de resultados for(i=0;i<=n-1;i++){ printf("%f\t",x[i]); } return 0; }
45
46
CASOS DE ESTUDIO.
47
