3.1 Sistema de ecuaciones 3×3, planos 3D con Python

Ejemplo: [ Ejercicio ] [ Analítico ] [ Algoritmo ] [ Python ]

Referencia: Chapra 9.1 p247
Como punto de partida para la unidad de sistema de ecuaciones, se usa un ejemplo para ilustrar la solución del sistema en gráficos para 3 ecuaciones y 3 incógnitas.

La solución es un punto de intersección de los planos en el espacio dados por cada ecuación en el sistema.

La intersección entre dos planos es una recta, que al añadir un plano adicional la intersección es un punto. Las coordenadas del punto es la solución buscada.

Para representar lo indicado, se realiza el desarrollo analítico del ejercicio junto al algoritmo y las gráficas en 3D con Python y Matplotlib.

Ejemplo: [ Ejercicio ] [ Analítico ] [ Algoritmo ] [ Python ]
..

1. Ejercicio

Referencia: 1Eva_IIT2011_T2 Sistema de Ecuaciones, diagonal dominante

Considere el siguiente sistema de ecuaciones AX=B dado por:

\begin{cases} -2x+5y+9z=1\\7x+y+z=6\\-3x+7y-z=-26\end{cases}

Se pueden representar como planos en el espacio despejando la variable z para cada ecuación, de la forma:

\begin{cases} z=(1+ 2x - 5y)/9\\z=(6 -7x-y)/1\\z=(-26+3x-7y)/(-1)\end{cases}

Ejemplo: [ Ejercicio ] [ Analítico ] [ Algoritmo ] [ Python ]
..

2. Desarrollo analítico. Ecuaciones como Planos en el espacio

Para diferenciar las ecuaciones, se añade el índice por filas i a cada una:

\begin{cases}f_0(x,y) : z=(1+ 2x - 5y)/9\\f_1(x,y) : z=(6 -7x-y)/1\\f_2(x,y) : z=(-26+3x-7y)/(-1)\end{cases}

Si observamos la primera ecuación en una gráfica, encontramos que para realizar el plano se requiere definir los intervalos para los ejes X, Y, por ejemplo:

-5 ≤ x ≤ 5
-7 ≤ y ≤ 7

Al combinar los planos Z₀ y Z₁, encontramos que la solución al sistema es la recta intersección de ambos planos.

Usando la tercera ecuación, la intersección de los planos genera un punto cuyas coordenadas corresponden a la solución del sistema.

Recta intersección de planos Z0 y Z1

Usando solo las dos primeras ecuaciones y considerando para el eje ‘y’ una constante, por ejemplo el lado izquierdo del intervalo y_a.

\begin{cases} -2x+5y_a+9z=1\\7x+y_a+z=6\end{cases}

Se reordenan las ecuaciones y reemplazan valores:

\begin{cases} -2x+9z=1-5y_a\\7x+z=6-y_a\end{cases}

\begin{cases} -2x+9z=1-5(-7)\\7x+z=6-(-7)\end{cases}

Al resolver las ecuaciones se encuentra un punto de la recta de intersección, del lado izquierdo del intervalo para el eje y. Se aplica el mismo proceso para el lado derecho del intervalo del eje ‘y‘ y se tienen las coordenadas:

array([[ 1.24615385, -7.        ,  4.27692308],
       [ 0.38461538,  7.        , -3.69230769]])

Con las que se puede trazar la línea de intersección entre los planos Z0 y Z1

Ejemplo: [ Ejercicio ] [ Analítico ] [ Algoritmo ] [ Python ]
..

3. Algoritmo en Python

Para observar el sistema de ecuaciones en un gráfico de tres dimensiones, se utilizan gráficas 3D y observar los resultados con varios puntos de vista al rotar el gráfico con el cursor.

Para el algoritmo, las ecuaciones del sistema se escriben en forma matricial Ax=B.

\begin{cases} -2x+5y+9z=1\\7x+y+z=6\\-3x+7y-z=-26\end{cases}

A es una matriz de coeficientes cuadrada, el número de filas es igual al de columnas. B es un vector de constantes, con el mismo número de elementos que filas de A.

# INGRESO Ax=B
A = [[-2, 5, 9],
     [ 7, 1, 1],
     [-3, 7,-1]]

B = [1,6,-26]

Las ecuaciones de cada plano escriben usando los coeficientes de A y B, según lo realizado en el desarrollo analítico al despejar la variable z. Cada ecuación es una expresión de dos variables (x,y), para simplificar se usa el formato lambda x,y.

# Ecuaciones de planos
f0 = lambda x,y: (B[0]-A[0,0]*x-A[0,1]*y)/A[0,2]
f1 = lambda x,y: (B[1]-A[1,0]*x-A[1,1]*y)/A[1,2]
f2 = lambda x,y: (B[2]-A[2,0]*x-A[2,1]*y)/A[2,2]

Ejemplo: [ Ejercicio ] [ Analítico ] [ Algoritmo ] [ Python ]

Para la gráfica 3D se requiere usar intervalos para las variables independientes x,y de forma semejante a las gráficas en 2D. En cada intervalo se realizaran muestras en varios puntos del intervalo. La combinación de muestras en cada eje, generan puntos en el plano X,Y.

3.1 Se generan las muestras para cada eje en los vectores xi, yj

xa = -5    # Intervalo [xa,xb] para eje x
xb = 5
ya = 7     # Intervalo [ya,yb] para eje y
yb = -7
muestras = 11

xi = np.linspace(xa,xb, muestras)
yj = np.linspace(ya,yb, muestras)

el resultado de las muestras en cada eje para el ejercicio es:

>>> xi
array([-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.])
>>> yj
array([-7. , -5.6, -4.2, -2.8, -1.4,  0. ,  1.4,  2.8,  4.2,  5.6,  7. ])
>>>

3.2 Las combinaciones entre las muestras de cada eje se realizan en las matrices Xi, Yj.

Xi, Yj = np.meshgrid(xi,yj)

Cada matriz representa una malla de puntos en el plano, usando luego cada punto para evaluar el valor de Z. El resultado son las matrices con los puntos de evaluación en la malla. Por ejemplo el primer punto [x₀,y₀] = [-5,-7]:

>>> Xi
array([[-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.],
       [-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.],
       [-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.],
       [-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.],
       [-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.],
       [-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.],
       [-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.],
       [-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.],
       [-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.],
       [-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.],
       [-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.]])
>>> Yj
array([[-7. , -7. , -7. , -7. , -7. , -7. , -7. , -7. , -7. , -7. , -7. ],
       [-5.6, -5.6, -5.6, -5.6, -5.6, -5.6, -5.6, -5.6, -5.6, -5.6, -5.6],
       [-4.2, -4.2, -4.2, -4.2, -4.2, -4.2, -4.2, -4.2, -4.2, -4.2, -4.2],
       [-2.8, -2.8, -2.8, -2.8, -2.8, -2.8, -2.8, -2.8, -2.8, -2.8, -2.8],
       [-1.4, -1.4, -1.4, -1.4, -1.4, -1.4, -1.4, -1.4, -1.4, -1.4, -1.4],
       [ 0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ,  0. ],
       [ 1.4,  1.4,  1.4,  1.4,  1.4,  1.4,  1.4,  1.4,  1.4,  1.4,  1.4],
       [ 2.8,  2.8,  2.8,  2.8,  2.8,  2.8,  2.8,  2.8,  2.8,  2.8,  2.8],
       [ 4.2,  4.2,  4.2,  4.2,  4.2,  4.2,  4.2,  4.2,  4.2,  4.2,  4.2],
       [ 5.6,  5.6,  5.6,  5.6,  5.6,  5.6,  5.6,  5.6,  5.6,  5.6,  5.6],
       [ 7. ,  7. ,  7. ,  7. ,  7. ,  7. ,  7. ,  7. ,  7. ,  7. ,  7. ]])
>>>

3.3 La matriz de resultados Z_i, se genera al evaluar una ecuación en cada punto (i, j). Como hay una ecuación por cada fila, se usa el índice para diferencial cada resultado Z_i.

Z0 = f0(Xi,Yj)
Z1 = f1(Xi,Yj)
Z2 = f2(Xi,Yj)

El gráfico del plano Z₀, se realiza con las matrices X_i,Y_j, con la instrucción wireframe(Xi,Yj,Z0) de las librerías 3D. Luego se repite el procedimiento para Z1 y Z2.

graf3D.plot_wireframe(Xi,Yj,Z0,
                      color ='blue',
                      label='Z0')

Si es necesario, revise la sección de Gráficas 3D para wireframe.

Para simplicidad del algoritmo, pues la revisión del concepto es sobre intersección de planos, la solución se obtiene con las funciones de Numpy.

punto = np.linalg.solve(A,B)

Ejemplo: [ Ejercicio ] [ Analítico ] [ Algoritmo ] [ Python ]
..

4. Instrucciones en Python

# Sistema de ecuaciones 3x3
# Interseccion de Planos
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import axes3d

# INGRESO Ax=B
A = [[-2, 5, 9],
     [ 7, 1, 1],
     [-3, 7,-1]]
B = [1,6,-26]

xa = -5     # Intervalo Xi ,[ax,bx]
xb = 5
ya = -7     # Intervalo Yj ,[ay,by]
yb = 7
muestras = 11 # en cada intervalo

# PROCEDIMIENTO
# matriz y vector como Numpy
A = np.array(A,dtype=float)
B = np.array(B,dtype=float)

# solucion al sistema
punto = np.linalg.solve(A,B)

# Interseccion entre ecuacion Z0 y Z1
A01  = np.copy(A[0:2,[0,2]])
# usando ay, extremo izquierdo eje y
B01  = B[0:2] - ya*A[0:2,1]
x01 = np.linalg.solve(A01,B01)
recta01 = [x01[0],ya,x01[1]]  # tabla coordenadas
# usando by, extremo derecho eje y
B01 = B[0:2] - yb*A[0:2,1]
x01 = np.linalg.solve(A01,B01)
recta01 = np.concatenate(([recta01 ],
                      [[x01[0],yb,x01[1]]]),
                     axis=0)

# ecuaciones de planos
f0 = lambda x,y: (B[0]-A[0,0]*x-A[0,1]*y)/A[0,2]
f1 = lambda x,y: (B[1]-A[1,0]*x-A[1,1]*y)/A[1,2]
f2 = lambda x,y: (B[2]-A[2,0]*x-A[2,1]*y)/A[2,2]

# muestras
xi = np.linspace(xa,xb, muestras)
yj = np.linspace(ya,yb, muestras)
Xi, Yj = np.meshgrid(xi,yj) # en plano XY

# evalua planos Zi
Z0 = f0(Xi,Yj)
Z1 = f1(Xi,Yj)
Z2 = f2(Xi,Yj)

# SALIDA
print('respuesta de A.X=B : ')
print(punto)

# GRAFICA 3D
fig3D = plt.figure()
graf3D = fig3D.add_subplot(111, projection='3d')

# Planos
graf3D.plot_wireframe(Xi,Yj,Z0,
                       color ='blue',
                       label='Z0')
graf3D.plot_wireframe(Xi,Yj,Z1,
                       color ='orange',
                       label='Z1')
graf3D.plot_wireframe(Xi,Yj,Z2,
                       color ='green',
                       label='Z1')

# recta entre planos Z0 y Z1
graf3D.plot(recta01[:,0],recta01[:,1], recta01[:,2],
            color='purple',
            label='recta01',
            linewidth=4)

# Punto solucion Z0,Z1,Z2
graf3D.plot(punto[0],punto[1],punto[2],
            'o',color='red',
            label='Punto',
            linewidth=6)

# etiquetas y entorno gr fico
graf3D.set_title('Sistema de ecuaciones 3x3')
graf3D.set_xlabel('x')
graf3D.set_ylabel('y')
graf3D.set_zlabel('z')
graf3D.set_xlim(xa, xb)
graf3D.set_ylim(ya, yb)
graf3D.legend()
graf3D.view_init(45, 45) # elevacion, azimut

### rotacion de ejes
##for angulo in range(45, 360+45, 5 ):
##    graf3D.view_init(45, angulo)
##    plt.draw()
##    plt.pause(.1)

plt.show()

Ejemplo: [ Ejercicio ] [ Analítico ] [ Algoritmo ] [ Python ]

Referencia: Dear linear algebra students, This is what matrices (and matrix manipulation) really look like. Zach Star. 5 mar 2020.

Ejemplo: [ Ejercicio ] [ Analítico ] [ Algoritmo ] [ Python ]