¿Cómo se descomponen las matrices en transformaciones lineales?
Las matrices, cuando se piensan como transformaciones lineales, ofrecen una herramienta poderosa para manipular diferentes vectores en un espacio. Una matriz A puede descomponerse en otras tres matrices, cada una representando su propia transformación lineal. Entender sus efectos es crucial, ya que estas transformaciones repercuten de la misma manera sin importar los vectores a los que se apliquen. Vamos a sumergirnos en el mundo de las matrices y su relación con el círculo unitario.
¿Qué es el círculo unitario y por qué lo utilizamos?
El círculo unitario es una herramienta gráfica que ayuda a visualizar los efectos de estas transformaciones. Dicho de otro modo, se trata de un círculo centrado en el origen (0,0) con radio 1. Su papel es esencial en el estudio de las transformaciones lineales, ya que permite observar de forma clara los cambios que dichas transformaciones generan, tal como la rotación o el escalado de vectores dentro del espacio.
¿Cómo graficar el círculo unitario?
Para graficar el círculo unitario y aplicar transformaciones, necesitamos Python y la biblioteca numpy para cálculos y matplotlib para la visualización. El siguiente código muestra cómo lograr esto:
import numpy as np
import matplotlib.pyplot as plt
defgraficar_matriz(matriz, vector_colores=['r','b']):# Definimos el círculo unitario x = np.linspace(-1,1,1000) y = np.sqrt(1- x**2)# Transformación del círculo por la matriz x1 = matriz[0,0]* x + matriz[0,1]* y
y1 = matriz[1,0]* x + matriz[1,1]* y
x1_neg = matriz[0,0]* x - matriz[0,1]* y
y1_neg = matriz[1,0]* x - matriz[1,1]* y
# Graficamos los vectores transformados plt.plot(x1, y1, color='g', alpha=0.7) plt.plot(x1_neg, y1_neg, color='g', alpha=0.7) plt.axhline(0, color='black', lw=1) plt.axvline(0, color='black', lw=1) plt.xlim(-1.5,1.5) plt.ylim(-1.5,1.5) plt.gca().set_aspect('equal', adjustable='box') plt.show()# Ejemplo con una matriz de identidadmatriz_identidad = np.array([[1,0],[0,1]])graficar_matriz(matriz_identidad)
¿Cómo aplicar transformaciones sin modificar el gráfico original?
Al probar el efecto de diferentes matrices, es esencial luego visualizar cómo estas cambian el círculo unitario en tiempo real. Las matrices de diferentes valores cambian la forma del círculo original, visualizando el impacto de la transformación lineal aplicada. A continuación, se muestra cómo se implementa este concepto:
# Definimos una matrizA = np.array([[3,7],[5,2]])# Graficamos el círculo unitario originalgraficar_matriz(np.eye(2))# Matriz identidad# Graficamos el círculo unitario transformadograficar_matriz(A)
¿Qué observamos con las matrices aplicadas?
Al aplicar la matriz A, observamos cómo los vectores base del círculo unitario original (los puntos cardinales) se transforman. Por ejemplo:
El vector (1, 0) se desplaza de su posición original.
El vector (0, 1) también cambia, conforme a los componentes de A, obteniendo un nuevo espacio transformado.
Esta aplicación práctica nos permite ver cómo actúa la matriz sobre los vectores del círculo y nos ofrece una comprensión palpable de las transformaciones lineales.
Recomendaciones prácticas
Para entender y visualizar de manera efectiva las transformaciones lineales mediante matrices:
Practica con diversas matrices: Cambia los valores de las matrices para observar distintos efectos en el círculo unitario.
Documenta tus observaciones: Mantén un registro de cómo cambian los vectores con diferentes matrices, te ayudará a entender patrones.
Explora visualmente y analíticamente: Usa las gráficas para ver el cambio y luego calcula los valores para confirmar lo que ves.
Profundiza en la teoría: Revisa la teoría matemática detrás de estas transformaciones para una comprensión más sólida.
Estas recomendaciones no solo abrillantan tus habilidades matemáticas sino también potencian tu capacidad de programación aplicada a problemas matemáticos.
¡Continúa explorando y ampliando tu conocimiento en transformaciones lineales!
ya que numpy nos permite devolver una matriz identidad con np.eye
Sii es exactamente lo mismo!
matematicamente un circulo es x^2+y^2=r
donde r es el radio, como es el circulo unitario r=1, x^2+y^2=1.
al despejar y queda la expresion: sqrt(1-x^2)
x va de -1 a 1 ya qiue es el dominio de la funcion, sabemos que la raiz cuadrada sqrt(x) esta definida en lo reales para los valores de x>=0 si fuera un negativo da un numero complejo.
Entonces tenemos que hacer 1-x^2>=0
x^2>=1
-1<x< 1
al modificar x e y ya sea diviendolos o restando a sus valor el circulo se puede transformar en parabola, elipse, hiperbola u otra
esta errorena la ecuación del circulo amigo. Es x^2+ y^2=r^2
gracias por el aporte
Como dice el profesor una matriz es una transformación lineal. Esta transformación para ser aplicada se usa el producto punto. Si analizan lo que escribió el profesor en #circulo unitario transformado, es el producto punto. Hice la misma función pero aplicando el producto punto directamente, si es que le sirve a alguien.
Un abrazo
def graficarMatriz(matriz, vectorCol=['red','blue']):
#círculo unitario
x = np.linspace(-1,1,100000) y = np.sqrt(1-(x**2)) #Transformamos x e y en una matriz de vectores x, y
vector_x_y = np.array([x, y])
# círculo unitario transformado
prod_punto = matriz.dot(vector_x_y)
#vectores
u1 =[matriz[0,0], matriz[1,0]] v1 =[matriz[0,1], matriz[1,1]]graficarVectores([u1, v1], cols=[vectorCol[0], vectorCol[1]]) plt.plot(prod_punto[0], prod_punto[1],'orange', alpha =0.7) plt.plot(-prod_punto[0],-prod_punto[1],'green', alpha =0.7)
Genial! Sí funciona
En clases anteriores se ha explicado que para realizar la transformación se debe de ejecutar el producto normal del vector con la matriz
vector_transformado =A.dot(vector)
durante esta clase no me queda muy claro en que mometo se realiza el producto normal lo que observo es que solo esta graficando dos vectores para el unitario y otros dos vectores para el unitario transformado, ¿en que momento se ejecuto el proucto normal?
después de un rato logré entender, me imagino que ya ud sabe pero lo comento para los siguientes, x e y en este caso, no son vectores (a pesar de que para numpy sean array), están representando funciones. una función y=f(x) (en este caso el circulo) está compuesta de infinitos puntos (x,y) en este caso, se está realizando el producto punto (interno, bruto, normal, como lo quiera llamar) de cada uno de los pares ordenados (x,y) pertenecientes a la función del circulo por la matriz de transformación, si sabe como realizar el producto punto manualmente, probablemente se de cuenta de que los renglones que el escribió de x1, y1, x1_neg, y1_neg corresponden al desarrollo del producto punto del punto (x,f(x))
Como dice Alexander, es en x1 y1 x1_neg y1_neg donde se esta realizando el producto interno de matrices, salvo que no lo hace a traves de la libreria de numpy como estabamos acostumbrados sino por el algoritmo "a mano" de operar filas con columnas; eso lo hace para un punto (x, y). La principal diferencia con este ejercicio es que es la primera vez que estamos dibujando una figura (que pide de input las coordenadas en listas separadas) y por ello tal procedimiento.
Estoy usando github copilot y tmr, me escribio todo antes que Sebastian!!!! jajajaajj, genial curso
Wow super interesante!
NO se cual es el propósito de todo el circulo unitario transformado o los vectores. NO da una explicación mas detallada de que se hace :(
es que no necesita mas explicacion es solo un ejemplo para que puedas apreciar lo que hace la transformación, en este caso como transforma el circulo a un tipo de elipse
Mi funcion para graficar lo visto en clase con plotly.
PD: Si no te queda igual, es porque debes correr primero
import plotly.graph_objectsas go
import plotly.ioas pio
pio.templates['new_template']= go.layout.Template()pio.templates['new_template']['layout']['font']={'family':'verdana','size':16,'color':'white'}pio.templates['new_template']['layout']['paper_bgcolor']='black'pio.templates['new_template']['layout']['plot_bgcolor']='black'pio.templates['new_template']['layout']['xaxis']={'title_standoff':10,'linecolor':'black','mirror':True,'gridcolor':'#EEEEEE'}pio.templates['new_template']['layout']['yaxis']={'title_standoff':10,'linecolor':'black','mirror':True,'gridcolor':'#EEEEEE'}pio.templates['new_template']['layout']['legend_bgcolor']='rgb(117, 112, 179)'pio.templates['new_template']['layout']['height']=700pio.templates['new_template']['layout']['width']=1000pio.templates['new_template']['layout']['autosize']=Falsepio.templates.default='new_template'
Aquí les dejo un pequeño cambio que hice en la función graficarMatriz
def plot_operator(M, colors=['red','blue']): # Se define el circulo unitario
theta = np.linspace(0,2*np.pi,5000) r =1 x0 = r * np.cos(theta) y0 = r * np.sin(theta)
# transformacion
x1 =M[0,0]* x0 +M[0,1]* y0
y1 =M[1,0]* x0 +M[1,1]* y0
# vectors
# Vectores que generan el espacio
u1 =M[:,0] v1 =M[:,1]plot_vector([u1, v1], colors) plt.plot(x1, y1,'green', alpha=0.7)
Tengo este error al ejecutar mi código.
Circulo unitario:---------------------------------------------------------------------------NameErrorTraceback(most recent call last)<ipython-input-5-796d83716487>in<module>()1print('Circulo unitario:')---->2graficarMatriz(np.array([[1,0],[0,1]]))3 plt.xlim(-1.5,1,5)4 plt.ylim(-1.5,1,5)5 plt.show()<ipython-input-2-b2a3de1aa38f>ingraficarMatriz(matriz, vectorCol)14 v1 =[matriz [0,1], matriz[1,1]]15--->16graficarVectores([u1, v1], cols =[vectorCol[0], vectorCol[1]])17 plt.plot(x1, y1,'green', alpha =0.7)18 plt.plot(x1_neg, y1_neg,'green', alpha =0.7)NameError: name 'graficarVectores' is not defined
Alguien me podría explicar que esta mal para poder corregirlo.
Al menos en el código que nos compartiste graficarVectores() no veo la función creada, en caso de estar en otro lado, se esta importando correctamente?
Es porque la función "graficarVectores" no esta definida, tenes que crearla o importarla si la tenes en otra parte como tiene el profe en un apartado de funciones auxiliares.
Para el que le interese la transformación de cizallamiento
plt.subplot(132)
plt.plot(cuadrado_cizallado_x[:, 0], cuadrado_cizallado_x[:, 1], label='Cizallamiento en X')
plt.title('Cizallamiento en el Eje X')
plt.axis('equal')
plt.subplot(133)
plt.plot(cuadrado_cizallado_y[:, 0], cuadrado_cizallado_y[:, 1], label='Cizallamiento en Y')
plt.title('Cizallamiento en el Eje Y')
plt.axis('equal')
plt.tight_layout()
plt.show()
Hola 👋 hice algunos ajustes a ambas funciones, de tal forma que se pueda especificar:
vectorCol (lista de colores)
lims => (xlim / ylim) recibe una lista de números
leyendas => (plt.legend) recibe una lista de strings
loc => (parámetro de legend para indicar posición de las leyendas) recibe los parámetros comunes de loc
Los tres últimos son opcionales. No es la graan cosa pero ayudan a tener una mejor visualización:
def graficarVectores(vectores , colores , alpha =0.7, lims =None, leyendas =None, loc =None): plt.axhline(y=0, color ='grey', linestyle ='--', zorder=0, alpha =0.3) #horizontal
plt.axvline(x=0, color ='grey', linestyle ='--', zorder=0, alpha =0.3) #vertical
for i inrange(len(vectores)): x = np.concatenate([[0,0], vectores[i]]) plt.quiver([x[0]],[x[1]],[x[2]],[x[3]], angles='xy', scale_units='xy', scale=1, color = colores[i], alpha = alpha, label = leyendas[i]if leyendas !=None and i <len(leyendas)elseNone)if lims !=None: plt.xlim(lims[0], lims[1]) plt.ylim(lims[0], lims[1])if leyendas !=None: plt.legend(loc = loc) plt.grid(alpha=0.4)def graficarMatriz(matriz , vectorCol=['blue','red'],lims =None, leyendas =None, loc ="best"):
#círculo unitario
x = np.linspace(-1,1,100000) y = np.sqrt(1-(x**2))
# círculo unitario transformado
x1 = matriz[0,0]* x + matriz[0,1]* y #positivas
y1 = matriz[1,0]* x + matriz[1,1]* y
x1_neg = matriz[0,0]* x - matriz[0,1]* y #negativas
y1_neg = matriz[1,0]* x - matriz[1,1]* y
#vectores
# coordenadas x
u1 =[matriz[0,0], matriz[1,0]] # coordenadas y
v1 =[matriz[0,1], matriz[1,1]]if lims !=None: plt.xlim(lims[0], lims[1]) plt.ylim(lims[0], lims[1])graficarVectores(vectores =[u1 , v1], colores =[vectorCol[0], vectorCol[1]], leyendas= leyendas, lims = lims, loc = loc) plt.plot(x1,y1,'green', alpha =0.7) plt.plot(x1_neg, y1_neg,'green', alpha =0.7)
-La función np.linalg.svd()devuelve tres valores: U, Sy V. La matriz U contiene los autovectores izquierdos, la matriz S es una matriz diagonal con los valores singulares en el orden descendente y la matriz V contiene los autovectores derechos.
Es importante tener en cuenta que en el caso de una matriz no cuadrada, la matriz S no será una matriz cuadrada, sino que tendrá dimensiones mxn, donde m es el número de filas de M yn es el número de columnas de M.
Recuerda que para utilizar NumPy, debes tener instalada la biblioteca en tu entorno de Python. Puedes instalarla usando el comando pip install numpysi aún no lo has hecho.
import numpy as np
# Definir una matriz no cuadrada
M= np.array([[1,2,3],[4,5,6]])# Calcular la descomposición SVDU,S,V= np.linalg.svd(M)# Imprimir las matrices U,S y Vprint("Matriz U:")print(U)print("Matriz S:")print(np.diag(S))print("Matriz V:")print(V)
Cual es el proposito de x1_neg y y1_neg en la funcion de graficar matriz?
como que grafica el circulo por partes primero los positivos luego los negativos
Mi gráfica
Mi gráfica
Cambie el código para que los círculos queden uno al lado del otro y se vea que tanto han cambiado:
# Definir las dos matrices que proporcionaste
unit_matrix = np.array([[1,0],[0,1]]) # Círculo unitario
new_matrix = np.array([[3,7],[5,2]]) # Nueva matriz para la transformación
# Crear una figura con dos subplots(1 fila,2 columnas)fig, axs = plt.subplots(1,2, figsize=(12,6)) # 1 fila,2 columnas
# Primer subplot:Círculo unitario
axs[0].set_title("Círculo unitario")axs[0].set_xlim(-8,8)axs[0].set_ylim(-8,8)plt.sca(axs[0]) # Configurar el primer subplot como el actual
graficarMatriz(unit_matrix, vectorCol=['red','blue']) # Llamar a la función con el círculo unitario
# Segundo subplot:Círculo unitario transformado
axs[1].set_title("Círculo unitario transformado")axs[1].set_xlim(-8,8)axs[1].set_ylim(-8,8)plt.sca(axs[1]) # Configurar el segundo subplot como el actual
graficarMatriz(new_matrix, vectorCol=['red','blue']) # Llamar a la función con el círculo transformado
# Ajustar la disposición de los subplots para que se vean bien
plt.tight_layout()# Mostrar los gráficos
plt.show()
hola aquí les dejo el codigo para graficar la matrix con algunas modificaciones
def plot_matrix(matrix, vectorCol=['red','blue']): #unitary circle
x = np.linspace(-1,1,100000) y =(1-(x**2))**0.5
#transform circle
x1 = matrix[0,0]*x+matrix[0,1]*y
y1 = matrix[1,0]*x+matrix[1,1]*y
x1_neg = matrix[0,0]*x-matrix[0,1]*y
y1_neg = matrix[1,0]*x-matrix[1,1]*y
#vectors
u1 =[matrix[0,0],matrix[1,0]] #base vector
v1 =[matrix[0,1],matrix[1,1]] plt.figure(figsize=(8,8)) plt.axis('equal') #make the numberline equal
plot_vectors([u1,v1],cols=vectorCol) u1_len=np.linalg.norm(u1) v1_len=np.linalg.norm(u1) base_v_x =[1*u1_len,0] base_v_y =[0,1*v1_len]plot_vectors([base_v_x,base_v_y],cols=vectorCol,alpha=0.5) #plot basis vectors
plt.plot(x1,y1,'green',alpha=0.7) plt.plot(x1_neg,y1_neg,'green',alpha=0.7)
