28-10-2021 Método de Gauss-

Jordán.
Solución de un sistema de
ecuaciones lineales.

Edgar Ernesto Granados Betancourt

UNIVERSIDAD DE GUANAJUATO. DIVISION DE CIENCIAS E
INGENIERIAS
Sea un sistema de n ecuaciones lineales con n incógnitas, el cual tiene la siguiente
forma:

𝑎11 𝑥1 + 𝑎12 𝑥2 + ⋯ + 𝑎1𝑛 𝑥𝑛 = 𝑏1

𝑎21 𝑥1 + 𝑎22 𝑥2 + ⋯ + 𝑎2𝑛 𝑥𝑛 = 𝑏2
⋮
𝑎𝑛1 𝑥1 + 𝑎𝑛2 𝑥2 + ⋯ + 𝑎𝑛𝑛 𝑥𝑛 = 𝑏𝑛

Este sistema se puede resolver mediante el uso de matrices, de tal forma que
tendremos la siguiente ecuación matricial:

𝐴𝑋 = 𝐵
Donde:
𝑎11 𝑎12 … 𝑎1𝑛
𝑎 𝑎22 … 𝑎2𝑛
𝐴 = ( 21 )
⋮ ⋮ ⋮ ⋮
𝑎𝑛1 𝑎𝑛2 … 𝑎𝑛𝑛

La cual es denominada matriz de coeficientes. Y sea

𝑏1
𝑏
𝐵 = ( 2)
⋮
𝑏𝑛

Se debe de buscar la matriz solución X, la cual tendrá la siguiente forma:

𝑥1
𝑥
𝑋 = ( 2)
⋮
𝑥𝑛

Uno de los métodos para la resolución del sistema de ecuaciones lineales es el de

Gauss-Jordán el cual reduce por renglón la matriz de coeficientes a la forma
escalonada reducida por renglones usando en general el siguiente procedimiento
(Grossman, 2007):
- Se divide la primera fila, entre una constante, para hacer que el primer
elemento sea 1.
- Se eliminan los primeros elementos de la segunda y siguientes filas. Estos
se hacen al multiplicar la primera fila por ciertas constantes adecuadas y
sumándola a la segunda fila y siguientes filas, respectivamente, de manera
que, al sumar las filas, el primer elemento de las filas inferiores se haga cero.
- Se divide la segunda fila entre una constante de tal forma que el segundo
elemento sea 1 y después se hace uso de la segunda fila para eliminar los
segundos elementos de la primera y tercera (y sucesivas) filas.
-Se va repitiendo el procedimiento.

El método a mano es engorroso, para ello se construye un programa en Python.

Tenemos el siguiente sistema de ecuaciones:

𝑥1 + 𝑥2 + +3𝑥4 = 4
2𝑥1 + 𝑥2 − 𝑥3 + 𝑥4 = 1
3𝑥1 − 𝑥2 − 𝑥3 + 2𝑥4 = −3
−𝑥1 + 2𝑥2 + 3𝑥3 − 𝑥4 = 4

Sea la matriz de coeficientes:

Sea, ahora, la matriz de igualdad:

Se construye la matriz aumentada:

Se pueden realizar ciertas operaciones elementales en cada fila de la matriz

aumentada, las cuales son:
- Multiplicar o dividir una fila por un numero diferente de cero.
- Sumar un múltiplo de una fila a otra fila.
- Intercambiar filas.
El proceso de aplicar estas operaciones es para reducir la matriz aumentada
(proceso denominado reducción por filas o renglones) y generar una matriz
triangular. Cualquier columna que contiene el primer 1 en una fila en la siguiente fila
tendrá ceros en el resto de los elementos. El primer elemento diferente de cero en
una fila (si lo hay) se llama pivote para ese renglón.
La eliminación hacia adelante nos permite reducir el conjunto de ecuaciones a un
sistema triangular superior.
Se usa la sustitución hacia atrás para reemplazar sucesivamente el último (o primer)
valor en las ecuaciones por los otros elementos para que sus soluciones se vuelvan
también triviales, la cual
nos permite ir formando
una matriz diagonal
unitaria (aumentada).
 La solución va a ser, entonces la última columna de la matriz aumentada:

Se calcula la transpuesta para poder escribir la matriz de una forma

convencional, la cual es:
 Sea el código:
import numpy as np

print("----------------------------------------------------------------")
print(" Metodo de Gaus-Jordan ")
print(" AX=B ")
print("----------------------------------------------------------------")

# Se ingresan las matrices del sistema AX=B

#Se ingresa la matriz A, la cual tendra como elementos los coeficientes que acompañan a cada
una de las incognitas en el sistema de ecuaciones lineal
print(" ")
print(" Matriz A ")
A = np.array([[ 1, 1, 0, 3],
[ 2, 1,-1, 1],
[ 3,-1,-1, 2],
[-1, 2, 3,-1]])
print(A)
print(" ")
#Se ingresa la matriz B, la cual tendra como elementos los valores a los que son igual cada
ecuación del sistema ")
print(" Matriz B ")
B = np.array([[ 4],
[ 1],
[-1],
[ 4]])
print(B)
print(" ")
print("----------------------------------------------------------------")

# Evitar truncamiento en operaciones

A = np.array(A,dtype=float)

# Realizacion de la Matriz aumentada

AB = np.concatenate((A,B),axis=1)
AB0 = np.copy(AB)
print(" Matriz Aumentada ")
print(" ")
print(AB0)
print("----------------------------------------------------------------")
print(" Matriz triangular ")
print(" ")
# Pivoteo parcial por filas
tamano = np.shape(AB)
n = tamano[0]
m = tamano[1]

# Para cada fila en la matriz aumentada

for i in range(0,n-1,1):
# columna desde diagonal i en adelante
columna = abs(AB[i:,i])
dondemax = np.argmax(columna)

# dondemax no está en diagonal

if (dondemax !=0):
# intercambia filas
temporal = np.copy(AB[i,:])
AB[i,:] = AB[dondemax+i,:]
AB[dondemax+i,:] = temporal
AB1 = np.copy(AB)

# eliminacion hacia adelante que nos permite reducir el conjunto de ecuaciones a un sistema
triangular superior
for i in range(0,n-1,1):
pivote = AB[i,i]
adelante = i + 1
for k in range(adelante,n,1):
factor = AB[k,i]/pivote
AB[k,:] = AB[k,:] - AB[i,:]*factor
AB2 = np.copy(AB)
rounded_array = np.round(np.copy(AB)) #Redonde los elementos de la matriz
print(rounded_array)
print(" ")
print("----------------------------------------------------------------")
 # Eliminacion hacia atras de la matriz triangular
print(" Matriz diagonal unitaria aumentada ")
print(" ")
ultimafila = n-1
ultimacolumna = m-1
for i in range(ultimafila,0-1,-1):
pivote = AB[i,i]
atras = i-1
for k in range(atras,0-1,-1):
factor = AB[k,i]/pivote
AB[k,:] = AB[k,:] - AB[i,:]*factor
# diagonal a unos
AB[i,:] = AB[i,:]/AB[i,i]
print(AB)
print(" ")
#Mostramos la solución
X = np.copy(AB[:,ultimacolumna])
print("----------------------------------------------------------------")
print(' Solución de X')
print("----------------------------------------------------------------")
X = np.transpose([X])
print(X)

Referencias:

- Grossman, Stanley. Álgebra lineal. Sexta edición. 2007. McGrawHill.