GAUSS-JORDAN

Jorge Celis
Oriolson Rodriguez
Oscar Alberto Estevez
Octavio Bonnet
 Contenido
1) Introducción
2) Eliminación Gaussiana
3) Algoritmo Matemático
4) Ejemplo
5) Diagrama de flujo
6) Código de programación:
 Fortran
 JAVA
 Introduccion
• La eliminación Gaussiana, también llamado como eliminación de
Gauss o eliminación de Gauss-Jordan, llamadas así debido a Carl Friedrich
Gauss y Wilhelm Jordan. Aunque el método fue presentado por Gauss se conocía
anteriormente en un importante libro matemático chino llamado Jiuzhang
suanshu o Nueve capítulos del arte matemático.
 Eliminación Gaussiana
• La eliminación Gaussiana es un algoritmo del álgebra lineal para determinar las
soluciones de un sistema de ecuaciones lineales, encontrar matrices e inversas.
• La complejidad computacional de la eliminación gaussiana es aproximadamente n3.
Esto es, el número de operaciones requeridas es n3 si el tamaño de la matriz es n × n

Sistema de ecuaciones linéales Matriz aumentada resultante

_ x 1 x 2 ........ x n
a12 x1  a13 x2  .....  a1n xn  b1
 a11 a12 ........ a1 n   b1 
a21 x1  a22 x2  .....  a2 n xn  b2   
 a 21 a 22 ........ a 2 n   b2 
    
am1 x1  am 2 x2  .....  amn xn  bm   
 a a ....... a  b 
 m1 m 2 mn  m 
 Algoritmo Matemático
1. Ir a la columna no cero extrema izquierda

2. Si el primer renglón tiene un cero en esta columna, intercambiarlo con otro que no lo tenga
Si
 a12 a11 ........ a1 n   b1 
a11  0 ,  , a12  0  
 a 22 a 21 ........ a 2 n
 
 b2 
   
  
 a a ....... a  b 
 m 2 m1 mn  m 
3. Luego, obtener ceros debajo de este elemento delantero, sumando
múltiplos adecuados del renglón superior a los renglones debajo de él. Este
proceso se realiza por medio de las siguientes operaciones:
• Multiplicar una ecuación por un escalar no nulo.
• Intercambiar de posición dos ecuaciones
• Sumar a una ecuación un múltiplo de otra.

 a12 a1 n   b1 
 a11 a12 ........ a1 n   b1   1 ........  
    a11 a11   a11 
 a 21 a 22 ........ a 2 n   b2  1  a a ........ a  b 
     F 1 * ( ) 
a11  21 22 2n
 2 
      
 a a ....... a  b 
 m1 m 2 mn  m   a a ....... a  b 
 m1 m 2 mn  m 
  b1 
 a12 a   b1   a12 a  
1 ........ 1 n   1 ........ 1 n   a11 
 a11 a11   a11   a11 a11  
 a a ........ a  b   F 2  F1* a   0 a 22 ........ a 2 n   b 2  b1 
 21 22 2n
 2  21
  a11 
      
 a a ....... a  b   a a ....... a  
 m1 m 2  m   m1 m 2  b 
mn mn 
 m 
4. Cubrir el renglón superior y repetir el proceso anterior con la submatriz restante.
Repetir con el resto de los renglones (en este punto la matriz se encuentra en la
forma de escalón)

 1 ..a12 ... a13 ... a1 n 

 
 0 ... 1 .... a13 .... a 2 n 
 0 .... 0 .... 1 ... a 
 3n

  
 
 0 ........ 0 ....... 1 
 5. Comenzando con el último renglón no cero, avanzar hacia arriba: para
cada renglón obtener un 1 delantero e introducir ceros arriba de este
sumando múltiplos correspondientes a los renglones correspondientes

 1 ..a12 ... a13 ... a1 n   1 ... a12 ... a13 ... a1 n 

   
 0 ... 1 .... a13 .... a 2 n   0 ... 1 .... a 23 .... a 2 n 
 0 .... 0 .... 1 ... a   F ( n  1)  Fn * ( a )   0 .... 0 .... 1 ... 0 
 3n  3n  
     
   
 0 ........ 0 ....... 1   0 ........ 0 ....... 1 

Repetimos este procedimiento hasta llegar a una matriz escalonada reducida.

6. Luego obtenemos las soluciones del sistema de ecuaciones

 x1 ... 0 .... 0 ... 0   b1 

  
 0 ... x 2 .... 0 .... 0   b 2 
 0 .... 0 .... x 3 ... 0   b 3 
  
    
 0 ........ 0 ....... xn   bn 
  
Luego, la solución es:

x1  b1
x2  b2

xn  bn
 Ejemplo
• Supongamos que es necesario encontrar los números x, y, z, que satisfacen
simultáneamente estas ecuaciones:

2x  y  z  8
 3 x  y  2 z  11
 2 x  y  2 z  3
• Del anterior sistema de ecuaciones resulta, la siguiente matriz aumentada:

 1 1/2 1/2 4 
2 1 1 8 1  
 F *( )  3 1 2 11

3 1 2 11 1
2 2 1 
2  2 3
 1 2 3

1 1/2 1/2 4
3F1 F2   
 2F1F3
0 1/2 1/2 1
0 2 
 1 5
 1 1/2 1/2 4
 
F2 *2 0 1 1 2
0 2 1 5
 

1 0 1 3
(1/ 2)F2 F1   
 0 1 1 2
2F2F3 0 0 1 1
 
 X Y Z
F3 F2 1 0 0 2
 
 F3 F1  0 1 0 3
0 0 1 1
F3 *1 
Luego la solución de este sistema de ecuaciones es:

x  2; y  3; z  1
 Diagrama de Flujo
INICIO
i
i=1,n,1 1 a11 a12  a1n f1
j
a21 a22  a2 n f2
j=1,n,1
   
an1 an 2  ann fn
M(j,i)

F(i) M nxn fj
 1
k
i=1,n,1 2 i
j=1,n,1
1 a12  a1n
j
0 1  a2 n
si i=j no
  
k=i,n,1 k=i,n,1
0 0  1
M(j,k)=M(j,k)/M M(j,k)=M(j,k)-
(j,i) M(j,i)*M(i,k)

F(j)=F(j)-
F(i)=F(i)/M(j,i) M(j,i)*F(i)
 2
i
i=n,1,-1 x1x2  xn
j=i-1,1,-1 1 0  0 f1
F(j)=F(j)-

k=i,n,1
M(j,i)*F(i) 0 1  0 f2
   
M(j,k)=M(j,k)- j
M(j,i)*M(i,k) 0 0  1 fn
i=1,n,1 k

‘X’(i)=F(i)

FIN
 Código
• Fortran: do k=i,n,1
program gauss_Jordan m(j,k)=m(j,k)-a*m(i,k)
integer::i,j,n,k end do
real::a f(j)=f(j)-a*f(i)
real,allocatable::m(:,:) end if
real,allocatable::f(:) end do
read(*,*)n end do
allocate(m(n,n),f(n)) do i=n,1,-1
do i=1,n,1 do j=i-1,1,-1
read(*,*)f(i) a=m(j,i)
end do do k=j,n,1
do i=1,n,1 m(j,k)=m(j,k)-a*m(i,k)
read(*,*)m(i,1:n) end do
end do f(j)=f(j)-a*f(i)
do i=1,n,1 end do
do j=1,n,1 end do
if(i==j)then do i=1,n,1
a=m(j,i) write(*,*)’x’,(i),’=‘,f(i)
do k=i,n,1 end do
m(j,k)=(m(j,k))/(a) write(*,*)'bn'
end do write(*,*)m
f(i)=(f(i))/(a) close(25)
else end program gauss
a=m(j,i)
•JAVA:

package javaapplication1;
import javax.swing.JOptionPane;
import java.util.Scanner;
public class Gauss_Jordan {
public static void main(String[] args) {
int i,j,k,n;
double a;
double m[][],f[];
Scanner reader=new Scanner(System.in);
System.out.println("escriba n");
n=reader.nextInt();
m=new double [n][n];
f=new double [n];
for(i=0;i<n;i++){
f[i]=Double.parseDouble(JOptionPane.showInputDialog("f"+i));
for(j=0;j<n;j++){
m[i][j]=Double.parseDouble(JOptionPane.showInputDialog("M("+i+j+")"));}}
for(i=0;i<n;i++){
for(j=0;j<n;j++){
a=m[j][i];
if(i==j){
for(k=i;k<=n;k++){
m[j][k]=(m[j][k]/a);}
f[i]=(f[i]/a);}
else {
for(k=i;k<=n;k++){
m[j][k]=m[j][k]-a*m[i][k];}
f[j]=f[j]-a*f[i];}}}
for(i=n;i>=0;i--){
for(j=i-1;j>=0;j--){
a=m[j][i];
for(k=j;k<=n;k++){
m[j][k]=m[j][k]-a*m[i][k];}
f[j]=f[j]-a*f[i];}}
for(i=0;i<n;i++){
System.out.println("x"+i+"="+f[i]);}}}