3.4 Gauss-Jordan Método

Referencia: Chapra 9.7 p277 pdf301

Para la solución con Gauss-Jordan se procede con la matriz aumentada para aplicar:

  • eliminación hacia adelante de incógnitas
  • eliminación hacia atras de incógnitas

sigue el ejemplo01 para matrices, usando la forma de función para el algoritmo.

A = np.array([[4,2,5],
              [2,5,8],
              [5,4,3]])

B = np.array([[60.70],
              [92.90],
              [56.30]])

Se crea la matriz aumentada AB.
Para el procedo de eliminación hacia adelante, en cada fila el elemento diagonal será el pivote, con el que se crea el coeficiente para eliminación de términos hacia adelante.

Para la eliminación hacia atras, se normaliza la fila haciendo el elemento diagonal uno, para calcular el coeficiente.

matriz aumentada:
[[  4.    2.    5.   60.7]
 [  2.    5.    8.   92.9]
 [  5.    4.    3.   56.3]]
 *** Gauss elimina hacia adelante ***
coeficiente:  2.0
[[   4.     2.     5.    60.7]
 [   0.     8.    11.   125.1]
 [   5.     4.     3.    56.3]]
coeficiente:  0.8
[[   4.      2.      5.     60.7 ]
 [   0.      8.     11.    125.1 ]
 [   0.      1.2    -2.6   -15.66]]
coeficiente:  6.66666666667
[[   4.            2.            5.           60.7       ]
 [   0.            8.           11.          125.1       ]
 [   0.            0.          -28.33333333 -229.5       ]]
 *** Gauss-Jordan elimina hacia atras *** 
coeficiente:  0.0909090909091
[[  4.           2.           5.          60.7       ]
 [  0.           0.72727273   0.           3.27272727]
 [ -0.          -0.           1.           8.1       ]]
coeficiente:  0.2
[[ 0.8         0.4         0.          4.04      ]
 [ 0.          0.72727273  0.          3.27272727]
 [-0.         -0.          1.          8.1       ]]
coeficiente:  2.5
[[ 2.   0.   0.   5.6]
 [ 0.   1.   0.   4.5]
 [-0.  -0.   1.   8.1]]
aumentada: 
[[ 1.   0.   0.   2.8]
 [ 0.   1.   0.   4.5]
 [-0.  -0.   1.   8.1]]
X: 
[[ 2.8]
 [ 4.5]
 [ 8.1]]
>>> 

El algoritmo desarrollado por partes:

# Gauss Jordan
# Supone que los elementos de diagonal no son cero
# Tarea: verificar diagonal no tiene ceros
# Muestra proceso
import numpy as np

# INGRESO
A = np.array([[4,2,5],
              [2,5,8],
              [5,4,3]])

B = np.array([[60.70],
              [92.90],
              [56.30]])

# PROCEDIMIENTO
# Matriz aumentada
AB = np.concatenate((A,B), axis=1)
print('matriz aumentada:')
print(AB)

print(' *** Gauss elimina hacia adelante ***')
casicero = 0 # 1e-15
# Gauss elimina hacia adelante
tamano = np.shape(AB)
n = tamano[0]
m = tamano[1]
for i in range(0,n,1):
    pivote = AB[i,i]
    adelante = i+1 
    for k in range(adelante,n,1):
        if (np.abs(AB[k,i])>=casicero):
            coeficiente = pivote/AB[k,i]
            AB[k,:] = AB[k,:]*coeficiente - AB[i,:]
        else:
            coeficiente= 'division para cero'
        print('coeficiente: ',coeficiente)
        print(AB)

print(' *** Gauss-Jordan elimina hacia atras *** ')
# Gauss-Jordan elimina hacia atras
ultfila = n-1
ultcolumna = m-1
for i in range(ultfila,0-1,-1):
    # Normaliza a 1 elemento diagonal
    AB[i,:] = AB[i,:]/AB[i,i]
    pivote = AB[i,i] # uno
    # arriba de la fila i
    atras = i-1 
    for k in range(atras,0-1,-1):
        if (np.abs(AB[k,i])>=casicero):
            coeficiente = pivote/AB[k,i]
            AB[k,:] = AB[k,:]*coeficiente - AB[i,:]
        else:
            coeficiente= 'division para cero'
        print('coeficiente: ', coeficiente)
        print(AB)
X = AB[:,ultcolumna]
X = np.transpose([X])

# SALIDA
print('aumentada: ')
print(AB)
print('X: ')
print(X)

Tarea: implementar caso cuando aparecen ceros en la diagonal para dar respuesta, convertir a funciones cada parte