Ejercicio: 1Eva_IT2019_T3 Vector perpendicular a plano
Literal a
Para que un vector sea perpendicular a otro, se debe cumplir que
V1.V2 =0.
\begin{bmatrix} 2 \\ -3 \\ a \end{bmatrix} . \begin{bmatrix} b \\ 1 \\ -4 \end{bmatrix} = 0
se obtiene entonces la ecuación:
(2)(b)+(-3)(1)+(a)(-4)=0
2b -3 -4a =0
procediendo de la misma forma con los siguientes pares de vectores:
\begin{bmatrix} 2 \\ -3 \\ a \end{bmatrix} . \begin{bmatrix} 3 \\ c \\ 2 \end{bmatrix} = 0
se obtiene entonces la ecuación:
(2)(3)+(-3)(c)+(a)(2)=0
6 -3c +2a = 0
\begin{bmatrix} b \\ 1 \\ -4 \end{bmatrix} . \begin{bmatrix} 3 \\ c \\ 2 \end{bmatrix} = 2
se obtiene entonces la ecuación:
(b)(3)+(1)(c)+(-4)(2)=2
3b +c -8 =2
se obtiene el sistema de ecuaciones:
\begin{cases}-4a+2b=3 \\ 2a-3c=-6 \\3b+c=10 \end{cases}
Literal b
Se convierte a la forma matricial Ax=B
\begin{bmatrix} -4 && 2 && 0 \\ 2 && 0 && -3 \\ 0 && 3 && 1\end{bmatrix}.\begin{bmatrix} a \\b\\c \end{bmatrix} = \begin{bmatrix} 3 \\ -6 \\ 10 \end{bmatrix}
se crea la matriz aumentada:
\begin{bmatrix} -4 && 2 && 0 && 3 \\ 2 && 0 && -3 &&-6 \\ 0 && 3 && 1 && 10 \end{bmatrix}
se pivotea por filas buscando hacerla diagonal dominante:
\begin{bmatrix} -4 && 2 && 0 && 3 \\ 0 && 3 && 1 && 10 \\ 2 && 0 && -3 &&-6 \end{bmatrix}
se aplica el algoritmo de eliminación hacia adelante:
1ra Iteración
la eliminación del primer término columna es necesario solo para la tercera fila:
\begin{bmatrix} -4 && 2 && 0 && 3 \\ 0 && 3 && 1 && 10 \\ 2 -(-4)\Big( \frac{2}{-4}\Big) && 0-2\Big(\frac{2}{-4}\Big) && -3 -0\Big(\frac{2}{-4}\Big) &&-6 -3\Big(\frac{2}{-4}\Big) \end{bmatrix}
\begin{bmatrix} -4 && 2 && 0 && 3 \\ 0 && 3 && 1 && 10 \\ 0 && 1 && -3 && -4.5 \end{bmatrix}
2da Iteración
\begin{bmatrix} -4 && 2 && 0 && 3 \\ 0 && 3 && 1 && 10 \\ 0 && 1 -3\Big(\frac{1}{3}\Big) && -3-(1)\Big(\frac{1}{3}\Big) && -4.5-10\Big(\frac{1}{3}\Big) \end{bmatrix}
\begin{bmatrix} -4 && 2 && 0 && 3 \\ 0 && 3 && 1 && 10 \\ 0 && 0 && -\frac{10}{3} && -7.8333 \end{bmatrix}
Aplicando eliminación hacia atras
(-10/3)c = -7.8333
c = -7.8333(-3/10) = 2.35
3b +c = 10
b= (10-c)/3 = (10-2.35)/3 = 2.55
-4a +2b =3
a= (3-2b)/(-4) = (3-2(2.55))/(-4) = 0.525
como resultado, los vectores buscados:
v1 = (2,-3,0.525)
v2 = (2.55,1,-4)
v3 = (3,2.35,2)
comprobando resultados:
>>> np.dot((2,-3,0.525),(2.55,1,-4))
-4.440892098500626e-16
>>> np.dot((2,-3,0.525),(3,2.35,2))
-6.661338147750939e-16
>>> np.dot((2.55,1,-4),(3,2.35,2))
2.0
Los dos primeros resultados son muy cercanos a cero, por lo que se los considera válidos
literal c
Para usar el método de Jacobi, se despeja una de las variables de cada ecuación:
\begin{cases} a = \frac{2b -3}{4} \\b = \frac{10-c}{3} \\c = \frac{2a+6}{3} \end{cases}
usando el vector x(0) = [0,0,0]
1ra iteración
a = \frac{2b -3}{4} = \frac{2(0) -3}{4} = -\frac{3}{4}
b = \frac{10-c}{3} = \frac{10-0}{3} = \frac{10}{3}
c = \frac{2a+6}{3 }= \frac{2(0)+6}{3} = 2
x(1) = [-3/4,10/3,2]
diferencias = [-3/4-0,10/3-0,2-0] = [-3/4,10/3,2]
error = max|diferencias| = 10/3 = 3.3333
2da iteración
a = \frac{2b -3}{4} = \frac{2(10/3) -3}{4} = \frac{11}{12}
b = \frac{10-c}{3} = \frac{10-2}{3} = \frac{8}{3}
c = \frac{2a+6}{3} = \frac{2(-3/4)+6}{3} = \frac{3}{2}
x(2) = [11/12,8/3,3/2]
diferencias = [11/12-(-3/4),8/3-10/3,3/2-2] = [20/12, -2/3, -1/2]
error = max|diferencias| = 5/3= 1.666
3ra iteración
a = \frac{2b -3}{4} = \frac{2(8/3)-3}{4} = \frac{7}{12}
b = \frac{10-c}{3} = \frac{10-3/2}{3} = \frac{17}{6}
c = \frac{2a+6}{3} = \frac{2(11/12)+6}{3} = 2.6111
x(3) = [7/12, 17/6, 2.6111]
diferencias = [7/12-11/12, 17/6-8/3, 2.6111-3/2] = [-1/3, 1/6, 1.1111]
error = max|diferencias| = 1.1111
Los errores disminuyen en cada iteración, por lo que el método converge,
si se analiza en número de condición de la matriz A es 2, lo que es muy cercano a 1, por lo tanto el método converge.
Revisión de resultados
Resultados usando algoritmos desarrollados en clase:
matriz aumentada:
[[-4. 2. 0. 3. ]
[ 0. 3. 1. 10. ]
[ 2. 0. -3. -6. ]]
Elimina hacia adelante
[[-4. 2. 0. 3. ]
[ 0. 3. 1. 10. ]
[ 0. 1. -3. -4.5]]
Elimina hacia adelante
[[-4. 2. 0. 3. ]
[ 0. 3. 1. 10. ]
[ 0. 0. -3.333333 -7.833333]]
Elimina hacia adelante
[[-4. 2. 0. 3. ]
[ 0. 3. 1. 10. ]
[ 0. 0. -3.333333 -7.833333]]
Elimina hacia atras
[[ 1. -0. -0. 0.525]
[ 0. 1. 0. 2.55 ]
[-0. -0. 1. 2.35 ]]
el vector solución X es:
[[0.525]
[2.55 ]
[2.35 ]]
verificar que A.X = B
[[ 3.]
[10.]
[-6.]]
Número de condición de A: 2.005894
los resultados para [a,b,c]:
[0.525 2.55 2.35 ]
producto punto entre vectores:
v12: 0.0
v13: 1.3322676295501878e-15
v23: 2.0
Algoritmos en Python:
# 1Eva_IT2019_T3 Vector perpendicular a plano
import numpy as np
# INGRESO
A = np.array([[-4.,2,0],
[ 0., 3,1],
[ 2.,0,-3]])
B = np.array([3.,10,-6])
# PROCEDIMIENTO
B = np.transpose([B])
casicero = 1e-15 # 0
AB = np.concatenate((A,B),axis=1)
tamano = np.shape(AB)
n = tamano[0]
m = tamano[1]
print('matriz 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-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):
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]))
numcond = np.linalg.cond(A)
# para comprobar respuestas
v1 = [2,-3,X[0]]
v2 = [X[1],1,-4]
v3 = [3,X[2],2]
v12 = np.dot(v1,v2)
v13 = np.dot(v1,v3)
v23 = np.dot(v2,v3)
# SALIDA
print('\n Número de condición de A: ', numcond)
print('\n los resultados para [a,b,c]:')
print(X)
print('\n productos punto entre vectores:')
print('v12: ',v12)
print('v13: ',v13)
print('v23: ',v23)
Tarea, usar el algoritmo de Jacobi usado en el taller correspondiente.
