7. Módulo, distancia y normalización

7.1 Tres ideas estrechamente relacionadas

El módulo convierte un vector en una medida escalar de su tamaño. La distancia entre puntos es el módulo del vector que los conecta. La normalización transforma un vector no nulo en otro de módulo uno que conserva su orientación.

Estas operaciones aparecen al medir separaciones, limitar velocidades, dirigir objetos, comprobar colisiones o separar la intensidad de una magnitud de su dirección.

7.2 Módulo en dos dimensiones

Para v = (v_x, v_y), sus componentes forman los catetos de un triángulo rectángulo:

El módulo es siempre mayor o igual que cero y lleva la misma unidad que las componentes. Si v = (−6, 8) m/s, entonces |v| = 10 m/s. Los signos desaparecen al elevar al cuadrado, pero siguen siendo esenciales para la orientación.

function modulo2D(v) {
  return Math.hypot(v.x, v.y);
}

console.log(modulo2D({ x: -6, y: 8 }));

7.3 Módulo en tres dimensiones

En tres dimensiones incorporamos la componente z:

Math.hypot() admite cualquier cantidad de argumentos. Para v = (2, −3, 6), devuelve 7.

const vector3D = { x: 2, y: -3, z: 6 };
const modulo = Math.hypot(vector3D.x, vector3D.y, vector3D.z);
console.log(modulo);

7.4 Propiedades del módulo

• No negatividad: |v| ≥ 0.
• Vector nulo: |v| = 0 únicamente si v = 0.
• Simetría: |−v| = |v|.
• Escalado: |kv| = |k|·|v|.
• Desigualdad triangular: |a + b| ≤ |a| + |b|.

Estas propiedades son útiles tanto para razonar como para diseñar pruebas del código.

7.5 Distancia entre dos puntos

Sean A y B dos puntos del mismo sistema de referencia. La distancia es el módulo de B − A:

La distancia no posee sentido y cumple d(A, B) = d(B, A), aunque los vectores AB y BA sean opuestos.

function distancia(a, b) {
  return Math.hypot(b.x - a.x, b.y - a.y);
}

console.log(distancia({ x: -2, y: 1 }, { x: 4, y: 9 }));

7.6 Distancia, desplazamiento y recorrido

La distancia entre la posición inicial y la final no siempre coincide con la longitud del recorrido. Si una persona camina 3 m al este y vuelve 3 m al oeste, recorrió 6 m, pero la distancia entre sus posiciones inicial y final es 0 m y su desplazamiento es el vector nulo.

7.7 Normalizar un vector

Normalizar consiste en dividir cada componente por el módulo. Para un vector no nulo:

Si v = (3, 4), su módulo es 5 y su versión normalizada es u = (0,6; 0,8). Conserva dirección y sentido, pero su módulo vale uno.

function normalizar(v) {
  const modulo = Math.hypot(v.x, v.y);
  if (modulo === 0) return null;
  return { x: v.x / modulo, y: v.y / modulo };
}

console.log(normalizar({ x: 3, y: 4 }));

7.8 Por qué no puede normalizarse el vector nulo

Normalizar 0 exigiría dividir por cero. Además, el vector nulo no posee una dirección que podamos conservar. Una implementación debe decidir explícitamente qué hacer: devolver null, producir un error controlado o utilizar una dirección de respaldo suministrada por quien llama.

7.9 Separar dirección e intensidad

La normalización permite construir un vector con una intensidad deseada:

Si un personaje debe moverse hacia un objetivo a 5 m/s, primero calculamos objetivo − posición, normalizamos esa diferencia y multiplicamos el resultado por 5 m/s. Así, la rapidez no depende de qué tan lejos está el objetivo.

function velocidadHacia(posicion, objetivo, rapidez) {
  const dx = objetivo.x - posicion.x;
  const dy = objetivo.y - posicion.y;
  const distancia = Math.hypot(dx, dy);
  if (distancia === 0) return { x: 0, y: 0 };
  return { x: dx / distancia * rapidez, y: dy / distancia * rapidez };
}

console.log(velocidadHacia({ x: 1, y: 1 }, { x: 4, y: 5 }, 10));

7.10 Limitar un módulo

En simulaciones suele ser necesario imponer una rapidez o fuerza máxima. Si el módulo ya está dentro del límite, conservamos el vector; si lo supera, lo normalizamos y lo escalamos al valor máximo.

function limitarModulo(v, maximo) {
  const modulo = Math.hypot(v.x, v.y);
  if (modulo === 0 || modulo <= maximo) return { ...v };
  const factor = maximo / modulo;
  return { x: v.x * factor, y: v.y * factor };
}

console.log(limitarModulo({ x: 6, y: 8 }, 4));

Esta operación conserva la orientación cuando limita y evita alterar el objeto original.

7.11 Distancia al cuadrado

Si solo necesitamos comparar distancias, podemos evitar la raíz cuadrada. Como la función raíz es creciente para valores no negativos:

Esto es útil en comprobaciones repetidas, como buscar objetos cercanos. Sin embargo, el valor al cuadrado tiene unidades cuadradas y no debe mostrarse al usuario como si fuera una distancia.

7.12 Laboratorio de módulo y normalización

Arrastrá los puntos A y B o usá los controles. Alterná entre el vector original y el normalizado; la flecha unitaria se amplifica visualmente para que pueda compararse.

7.13 Precisión y tolerancias

Por redondeo, el módulo calculado de un vector normalizado puede ser 0,9999999999999999 en vez de 1. Conviene comparar con una tolerancia:

function aproximadamenteIguales(a, b, tolerancia = 1e-10) {
  return Math.abs(a - b) <= tolerancia;
}

const u = { x: 1 / Math.sqrt(2), y: 1 / Math.sqrt(2) };
console.log(aproximadamenteIguales(Math.hypot(u.x, u.y), 1));

Para vectores muy pequeños puede usarse una tolerancia para tratarlos como nulos, elegida según la escala y precisión del problema.

7.14 Errores frecuentes

• Confundir módulo con suma de componentes.
• Interpretar el módulo como vector en vez de escalar.
• Confundir distancia entre extremos con distancia recorrida.
• Dividir por cero al normalizar el vector nulo.
• Normalizar cada componente por separado.
• Redondear antes de terminar el cálculo.
• Mostrar distancia al cuadrado con unidades de distancia.
• Normalizar una velocidad cuando se necesitaba conservar su rapidez.

7.15 Ejercicio integrador

Un robot está en A = (−1, 2) m y su objetivo en B = (5, 10) m. Debe avanzar hacia B con rapidez constante de 3 m/s.

1. Calculá el vector AB.
2. Calculá la distancia entre el robot y el objetivo.
3. Normalizá AB.
4. Construí el vector velocidad de módulo 3 m/s.
5. Comprobá los módulos y calculá la distancia al cuadrado.

const A = { x: -1, y: 2 };
const B = { x: 5, y: 10 };
const AB = { x: B.x - A.x, y: B.y - A.y };
const distancia = Math.hypot(AB.x, AB.y);
const unitario = { x: AB.x / distancia, y: AB.y / distancia };
const rapidez = 3;
const velocidad = { x: unitario.x * rapidez, y: unitario.y * rapidez };
const distanciaCuadrada = AB.x ** 2 + AB.y ** 2;

console.log({ AB, distancia, unitario, velocidad, distanciaCuadrada });
console.log("Módulos:", Math.hypot(unitario.x, unitario.y), Math.hypot(velocidad.x, velocidad.y));

7.16 Ideas para recordar

• El módulo es una medida escalar no negativa.
• La distancia entre puntos es el módulo de su diferencia.
• Desplazamiento, distancia entre extremos y recorrido no son equivalentes.
• Normalizar divide un vector no nulo por su módulo.
• Un vector unitario conserva dirección y sentido, y tiene módulo uno.
• El vector nulo no puede normalizarse.
• Comparar distancias al cuadrado puede evitar cálculos innecesarios.
• Las comparaciones numéricas necesitan tolerancias razonables.

En el próximo tema estudiaremos vectores unitarios y bases ortonormales.