Las tres transformaciones

en vez de hacer

graficarMatriz(np.array([[1,0],[0,1]]))

pueden hacer esto :

graficarMatriz(np.eye(2))

ya que numpy nos permite devolver una matriz identidad con np.eye

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

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)

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?

Estoy usando github copilot y tmr, me escribio todo antes que Sebastian!!! jajajaajj, genial curso

Adjunto el código para graficar matriz

def graficarMatriz(matriz, vectorCol=['red','blue']):
  #circulo unitario
  x=np.linspace(-1,1,1000000)
  y=np.sqrt(1-x**2)

  #circulo unitario transformado
  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

  #vectores
  u1 = [matriz[0,0], matriz[1,0]]
  v1 = [matriz[0,1], matriz[1,1]]

  graficarVectores([u1,v1], cols=[vectorCol[0],vectorCol[0]])

  plt.plot(x1,y1, 'green', alpha =0.7)
  plt.plot(x1_neg,y1_neg, 'green', alpha =0.7)

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)

Aqui un interesante articulo para profundizar sobre el circulo unitario
https://www.lifeder.com/circulo-unitario/

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)