Ángulo entre vectores con producto punto

Curso de Álgebra Lineal: Fundamentos y Aplicaciones

Contenido del curso

No sé dónde empezar

Vectores

Matrices

Sistemas de Ecuaciones Lineales

Inversas y Determinantes

Cambio de Base

26
Cambio de base entre sistemas de coordenadas
14:58 min

Eigenvalores y Diagonalización

Tomar examen

Ángulo entre vectores con producto punto

Resumen

Calcular el ángulo entre dos vectores deja de ser un misterio cuando entiendes que el producto punto guarda dentro de sí una relación geométrica directa con el coseno del ángulo que separa esas dos flechas. Si ya sabes calcular el producto punto y la norma, te falta un solo paso para cuantificar qué tan alineados están dos vectores en el plano. Esto es útil para físicos, programadores, estudiantes de álgebra lineal y cualquiera que quiera dominar la base matemática detrás del machine learning.

¿Qué fórmula relaciona el producto punto con el ángulo entre vectores?

La fórmula central que une todo lo que ya sabes sobre vectores es esta: el producto punto entre U y V es igual a la norma de U multiplicada por la norma de V, multiplicada por el coseno del ángulo theta entre ellos [00:13].

Es una idea poderosa porque conecta dos mundos. Por un lado, tienes el cálculo algebraico del producto punto. Por el otro, tienes una interpretación geométrica basada en longitudes y ángulos. Ambos caminos llegan al mismo número.

¿Qué mide el producto punto entre dos vectores? Mide qué tan alineados están. Si el resultado es alto, apuntan en direcciones similares. Si es cero, son perpendiculares. Si es negativo, apuntan en direcciones opuestas.

¿Por qué se usa el coseno y no otra función trigonométrica?

El coseno se eligió porque sus valores reflejan con precisión la intuición de alineación entre vectores [00:42]. Hay tres casos clave que conviene memorizar:

Ángulo de 0 grados: los vectores están perfectamente alineados y el coseno vale 1, su máximo.
Ángulo de 90 grados: los vectores son perpendiculares y el coseno vale 0, ninguna alineación.
Ángulo de 180 grados: los vectores son opuestos y el coseno vale -1, máxima oposición.

Ninguna otra función trigonométrica captura esta idea de similitud de forma tan limpia. Por eso aparece una y otra vez en aplicaciones como la cosine similarity en inteligencia artificial.

¿Cómo despejar el ángulo theta de la fórmula?

En la fórmula original ya sabes calcular casi todo: el producto punto y las normas. Lo único desconocido es el ángulo, así que el siguiente paso es despejarlo [01:30].

Primero aíslas el coseno: el coseno de theta es igual al producto punto entre U y V, dividido entre la norma de U multiplicada por la norma de V. Luego aplicas la función inversa: theta es igual al arcocoseno de esa expresión completa.

Con una calculadora científica resuelves el arcocoseno sin problemas. Y aquí viene lo interesante: ya tienes una herramienta universal para medir el ángulo entre cualquier par de vectores.

¿Cómo aplicar la fórmula en un ejercicio práctico?

Imagina dos personas empujando una caja. La primera aplica una fuerza F1 igual al vector (3,1) y la segunda aplica una fuerza F2 igual al vector (1,2) [02:22]. Quieres saber el ángulo exacto entre sus esfuerzos.

¿Cuáles son los pasos para calcular el ángulo entre F1 y F2?

Vamos por partes, calculando cada componente antes de unirlas en la fórmula final.

Producto punto F1 · F2: multiplicas componente a componente: 3 por 1 más 1 por 2, lo que da 5.
Norma de F1: raíz cuadrada de 3 al cuadrado más 1 al cuadrado, es decir, raíz de 10.
Norma de F2: raíz cuadrada de 1 al cuadrado más 2 al cuadrado, es decir, raíz de 5.

Ahora reemplazas en la fórmula despejada. Theta es igual al arcocoseno de 5 dividido entre raíz de 10 por raíz de 5, lo que se simplifica a 5 sobre raíz de 50, aproximadamente 0,77. El arcocoseno de 0,77 da aproximadamente 45 grados [04:08].

¿Qué significa que dos vectores formen un ángulo de 45 grados? Significa que apuntan en direcciones similares pero no idénticas. Hay colaboración parcial: empujan hacia el mismo lado general, aunque cada uno con su propia inclinación.

¿Cómo verificar gráficamente el ángulo entre dos vectores?

Si dibujas F1 como una flecha hasta el punto (3,1) y F2 como otra flecha hasta el punto (1,2), notas visualmente que forman un ángulo cercano a 45 grados [04:38].

Un truco rápido para confirmarlo: si llevas F1 al eje X puro, dejándolo en (3,0), y F2 al eje Y puro, dejándolo en (0,2), obtienes dos vectores perpendiculares con un ángulo de 90 grados entre ellos. Eso te confirma que los originales formaban justo la mitad, 45 grados.

¿Qué interpretación tiene el ángulo en problemas reales?

El número 45 grados no es solo matemática abstracta. En el ejemplo de las personas empujando la caja, te dice que ambas colaboran en una dirección general parecida, aunque no perfectamente alineadas [05:28].

Si el ángulo fuera de 0 grados, empujarían exactamente en la misma dirección y la fuerza combinada sería máxima. Si fuera de 180 grados, empujarían en direcciones opuestas y se anularían. Acabas de usar álgebra lineal para cuantificar la colaboración entre dos fuerzas.

Como práctica, calcula el ángulo entre dos coches con vectores de velocidad: el coche A con vector (80,0), que se mueve a 80 kilómetros por hora hacia el este, y el coche B con vector (60,60), que combina 60 kilómetros por hora al este y 60 al norte [05:54]. Comparte tu proceso y tu resultado en los comentarios.

Danny Alejandro fernandez gallego

Estudiante

Acabo de hacer un simulador 2D de vectores en python, basicamente tiene tres archivos, operaciones, graficacion y visualización, aqui el codigo:

import numpy as np

"""
np.ndarray -> tipo de dato principal en numpy, significa 
N - dimensional array (Arreglode N dimensiones). Esrructura de
datos que permite almacenar numeros en forma de matriz o tensor

"""
def suma(u:np.ndarray,v:np.ndarray)-> np.ndarray:
    """Retorna la suma vectorial u + v """
    return u + v 

def resta(u:np.ndarray,v:np.ndarray)->np.ndarray:
    """Retorna la resta vectorial u + v """
    return u - v

def multiplicar_escalar(k: float, u:np.ndarray)-> np.ndarray:
    """ Retorna e vector resultante de multiplicar k * u """
    return k * u

# firma de la función
def producto_punto(u:np.ndarray,v: np.ndarray)->float:
    """ calcula el producto punto entre dos vectores """
    return float(np.dot(u,v))

def norma_l2(u: np.array)->float:
    """ Calcula la norma eucladiana o L2 de un vector """
    return float(np.linalg.norm(u))

def angulo_entre_vectores(u: np.ndarray,v: np.ndarray)->float:
    """
    Calcula el angulo entre u y v en grados.
    lanza error si alguno de los vectores es el ector 0
    """
    nu = norma_l2(u)
    nv = norma_l2(v)
    
    if nu == 0 or nv == 0:
       raise ValueError("No se puede calcular  el angulo con el vector en 0")
    
    cos_tetha = producto_punto(u, v) / (nu * nv)
    cos_tetha = np.clip(cos_tetha, -1.0, 1.0)
    return float(np.degrees(np.arccos(cos_tetha)))

def proyeccion_de_u_sobre_v(u: np.ndarray, v: np.ndarray) -> np.ndarray:
    """
    Calcula la proyección de u sobre v:
    proj_v(u) = (u·v / v·v) * v
    """
    if np.allclose(v, np.zeros_like(v)):
        raise ValueError("No se puede proyectar sobre el vector cero.")

    return (producto_punto(u, v) / producto_punto(v, v)) * v


def validar_vector_2d(vector: np.ndarray, nombre: str = "vector") -> None:
    """Valida que el vector tenga dos componentes."""
    if vector.shape != (2,):
     raise ValueError(f"{nombre} debe tener exactamente dos componentes.")

import numpy as np
import matplotlib.pyplot as plt

"""
La función recibe una lista de arrays de NumPy que 
representan vectores con al menos dos componentes (X, Y). 
Extrae las coordenadas X e Y, incluyendo el origen, y calcula 
el valor máximo absoluto en cada eje. A estos valores se les 
suma un margen para evitar que la gráfica quede ajustada a 
los datos. Finalmente, retorna una estructura de dos tuplas 
con los límites mínimos y máximos para los ejes X y Y, de 
forma simétrica respecto a cero.
"""

def _ajustar_limites(vectores: list[np.ndarray], margen:float=1.5)->tuple[tuple[float,float], tuple[float, float]]:
    """ Calcula limites automaticos para que la grafica sea legible """
    xs = [0.0]
    ys = [0.0]
    
    for vector in vectores:
        xs.append(float(vector[0]))
        ys.append(float(vector[1]))
    
    max_abs_x = max(abs(x) for x in xs) + margen
    max_abs_y = max(abs(y) for y in ys) + margen
    
    return (-max_abs_x, max_abs_x), (-max_abs_y, max_abs_y)

def graficar_escenario (
    u: np.ndarray,
    v: np.ndarray,
    suma_uv: np.ndarray,
    resta_uv: np.ndarray,
    proy_u_sobre_v: np.ndarray,
    guardar_como: str | None = None 
    )->None:
    """grafica los vectores y los resultados principales """
    
    fig, ax = plt.subplots(figsize=(8,8))
    
    vectores = [u, v , suma_uv, resta_uv, proy_u_sobre_v] 
    xlim, ylim = _ajustar_limites(vectores)
    
    ax.quiver(0, 0, u[0], u[1], angles="xy", scale_units="xy", scale=1, label="u")
    ax.quiver(0, 0, v[0], v[1], angles="xy", scale_units="xy", scale=1, label="v")
    ax.quiver(0, 0, suma_uv[0], suma_uv[1], angles="xy", scale_units="xy", scale=1, label="u + v")
    ax.quiver(0, 0, resta_uv[0], resta_uv[1], angles="xy", scale_units="xy", scale=1, label="u - v")
    ax.quiver(0, 0, proy_u_sobre_v[0], proy_u_sobre_v[1], angles="xy", scale_units="xy", scale=1, label="proj_v(u)")
    
    ax.set_xlim(*xlim)
    ax.set_ylim(*ylim)
    ax.axhline(0)
    ax.axvline(0)
    ax.grid(True)
    ax.set_aspect("equal", adjustable="box")
    ax.set_title("Simulador 2D de vectores")
    ax.legend()

    if guardar_como:
        plt.savefig(guardar_como, bbox_inches="tight", dpi=180)

    plt.show()

import numpy as np

from operaciones import (suma,
                        resta, 
                        multiplicar_escalar, 
                        producto_punto, 
                        norma_l2, 
                        angulo_entre_vectores, 
                        proyeccion_de_u_sobre_v, 
                        validar_vector_2d)

from visualizacion import graficar_escenario

def imprimir_resultados(u: np.ndarray, v:np.ndarray, k:float)->None: 
    validar_vector_2d(u, "u")
    validar_vector_2d(v, "v")
    
    suma_uv = suma(u, v)
    resta_uv = resta(u, v)
    ku = multiplicar_escalar(k, u)
    dot = producto_punto(u, v)
    norma_u = norma_l2(u)
    norma_v = norma_l2(v)
    angulo = angulo_entre_vectores(u, v)
    proy = proyeccion_de_u_sobre_v(u,v)
    
    print("=== IMPRIMIENDO RESULTADOS DEL SIMULADOR 2D ===")
    print(f"u = {u}")
    print(f"v = {v}")
    print(f"k = {k}")
    print(f"u + v = {suma_uv}")
    print(f"u - v = {resta_uv}")
    print(f"k * u = {ku}")
    print(f"u · v = {dot:.4f}")
    print(f"||u|| = {norma_u:.4f}")
    print(f"||v|| = {norma_v:.4f}")
    print(f"Ángulo(u, v) = {angulo:.4f} grados")
    print(f"proj_v(u) = {proy}")
    
    graficar_escenario(u, v, suma_uv, resta_uv, proy, guardar_como="grafica_vectores.png")

      
if __name__ == "__main__":
    #caso de prueba
    u = np.array([4.0, 3.0])
    v = np.array([2.0, 5.0])
    k = 2.5 
    
    imprimir_resultados(u, v, k)

Daniel Erazo

Profesor

Qué gran aporte!

Ángulo entre vectores con producto punto

Vectores

Álgebra lineal: el lenguaje de la IA

Qué es un vector y cómo graficarlo

Suma, resta y escala de vectores geométricamente

Combinaciones lineales y span de vectores

Qué hace un vector redundante en álgebra lineal

Producto punto: cómo medir alineación vectorial

Norma de un vector con Pitágoras