3.4.1 Gauss-Jordan Ejemplo01

Ref: Rodriguez Cap.4 Ejemplo 1 pdf.105

Ejemplo 1. Un comerciante compra tres productos A, B, C, pero en las facturas únicamente consta la cantidad comprada en Kg y el valor total de la compra. Se necesita determinar el precio unitario de cada producto.  Dispone de solo tres facturas con los siguientes datos:

Ejemplo:
Cantidad Valor ($)
Factura A B C Pagado
1 4 2 5 60.70
2 2 5 8 92.90
3 5 4 3 56.30

Los precios unitarios se pueden representar por x1, x2, x3 para generar el sistema de ecuaciones lineales con tres variables:

4 x1 + 2 x2 + 5 x3 = 60.70
2 x1 + 5 x2 + 8 x3 = 92.90
5 x1 + 4 x2 + 3 x3 = 56.30

para resolver:
\begin{pmatrix} 4 & 2 & 5 \\ 2 & 5 & 8 \\5 & 4 & 3 \end{pmatrix} \begin{pmatrix} x_1 \\ x_2 \\ x_3 \end{pmatrix} = \begin{pmatrix} 60.70 \\ 92.90 \\ 56.30 \end{pmatrix}

que para la computadora será:

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

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

algoritmo propuesto, tiene como resultado:

matriz aumentada: 
[[ 4.   2.   5.  60.7]
 [ 2.   5.   8.  92.9]
 [ 5.   4.   3.  56.3]]
Elimina hacia adelante
[[  4.        2.        5.       60.7    ]
 [  0.        4.        5.5      62.55   ]
 [  0.        0.       -5.3125  -43.03125]]
Elimina hacia atras
[[ 1.   0.   0.   2.8]
 [ 0.   1.   0.   4.5]
 [-0.  -0.   1.   8.1]]
el vector solución X es:
[[2.8]
 [4.5]
 [8.1]]
verificar que A.X = B
[[60.7]
 [92.9]
 [56.3]]
# Método de Gauss-Jordan ,
# Recibe las matrices A,B
# presenta solucion X que cumple: A.X=B
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
casicero = 1e-15 # 0
AB = np.concatenate((A,B),axis=1)
tamano = np.shape(AB)
n = tamano[0]
m = tamano[1]

print('aumentada: ')
print(AB)
# Gauss elimina hacia adelante
# tarea: verificar términos cero
for i in range(0,n,1):
    pivote = AB[i,i]
    adelante = i+1 
    for k in range(adelante,n,1):
        if (np.abs(pivote)>=casicero):
            factor = AB[k,i]/pivote
            AB[k,:] = AB[k,:] - factor*AB[i,:]
print('Elimina hacia adelante')
print(AB)

# Gauss 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):
            factor = pivote/AB[k,i]
            AB[k,:] = AB[k,:]*factor - AB[i,:]
        else:
            factor= 'division para cero'
print('Elimina hacia atras')
print(AB)

X = AB[:,ultcolumna]

# Verifica resultado
verifica = np.dot(A,X)

# SALIDA
print('el vector solución X es:')
print(np.transpose([X]))

print('verificar que A.X = B')
print(np.transpose([verifica]))

Finalmente, si verificamos los resultados multiplicando la matriz de cantidad por el vector resultante deberá obtener el vector de valor pagado:

>>> np.dot(cantidad,precio)
array([[ 60.7],
       [ 92.9],
       [ 56.3]])

una función de numpy que resuelve el sistema de ecuaciones:

>>> np.linalg.solve(cantidad, pagado)
array([[ 2.8],
       [ 4.5],
       [ 8.1]])