27. Vectores en el plano y en el espacio

27.1 Introducción

Un vector posee magnitud, dirección y sentido. En el plano se representa mediante dos componentes y en el espacio mediante tres.

Geométricamente suele dibujarse como una flecha. Algebraicamente se expresa como una lista ordenada de números, lo que facilita almacenarlo y procesarlo en un programa.

27.2 Punto y vector

Un punto indica una posición. Un vector describe un desplazamiento o una dirección. Ambos pueden usar las mismas coordenadas, pero su significado es diferente.

Esta distinción conceptual evita aplicar operaciones sin interpretar qué representa el resultado.

27.3 Componentes de un vector

Las componentes indican cuánto avanza el vector sobre cada eje. Su orden es esencial:

const v = [4, -2];
const [vx, vy] = v;

console.log({ vx, vy }); // { vx: 4, vy: -2 }

27.4 Vectores en ℝ²

Un vector de ℝ² puede visualizarse como una flecha en el plano cartesiano. Su componente x describe el desplazamiento horizontal y su componente y, el vertical.

27.5 Vector de posición

El vector que comienza en el origen O = (0, 0) y termina en un punto P = (x, y) se denomina vector de posición de P.

const origen = [0, 0];
const punto = [5, -3];
const vectorPosicion = punto.map((valor, i) => valor - origen[i]);

console.log(vectorPosicion); // [5, -3]

Por eso las coordenadas de un punto y las del vector que va desde el origen hasta él coinciden numéricamente.

27.6 Vector entre dos puntos del plano

Si A = (a_x, a_y) es el punto inicial y B = (b_x, b_y) el final, el vector que va de A a B es:

function vectorEntre(origen, destino) {
  if (origen.length !== destino.length) throw new Error("Dimensiones diferentes");
  return destino.map((valor, i) => valor - origen[i]);
}

console.log(vectorEntre([2, 1], [7, 4])); // [5, 3]

Invertir los puntos produce BA = −AB.

27.7 Extremo de un desplazamiento

Si un vector v se aplica desde un punto A, el extremo B se obtiene sumando sus componentes:

function desplazar(punto, vector) {
  return punto.map((coordenada, i) => coordenada + vector[i]);
}

const inicio = [2, 1];
const movimiento = [5, 3];
console.log(desplazar(inicio, movimiento)); // [7, 4]

Esta operación es habitual al actualizar posiciones en animaciones y videojuegos.

27.8 Vectores libres e igualdad

Un vector libre no está ligado a una posición particular. Dos flechas representan el mismo vector si tienen las mismas componentes, aunque comiencen en puntos diferentes.

const iguales = (u, v, tolerancia = 1e-10) =>
  u.length === v.length &&
  u.every((valor, i) => Math.abs(valor - v[i]) < tolerancia);

const AB = [3, 2];
const CD = [3, 2];
console.log(iguales(AB, CD)); // true

27.9 Vectores en ℝ³

En ℝ³ se agrega un tercer eje perpendicular a los ejes x e y. Un vector v = (v_x, v_y, v_z) describe un desplazamiento tridimensional.

• v_x: componente horizontal.
• v_y: componente vertical según la convención elegida.
• v_z: profundidad o tercer eje.

El significado visual de cada eje depende del sistema de coordenadas utilizado por la aplicación.

27.10 Vector entre dos puntos del espacio

La fórmula se extiende componente a componente:

const A = [1, -2, 3];
const B = [5, 1, -1];
const AB = B.map((coordenada, i) => coordenada - A[i]);

console.log(AB); // [4, 3, -4]

27.11 Ejes y vectores canónicos

Los vectores canónicos apuntan en la dirección positiva de cada eje:

Cualquier vector (x, y, z) puede escribirse como x e₁ + y e₂ + z e₃.

const e1 = [1, 0, 0];
const e2 = [0, 1, 0];
const e3 = [0, 0, 1];
const componentes = [4, -2, 5];

const v = e1.map((_, i) =>
  componentes[0] * e1[i] + componentes[1] * e2[i] + componentes[2] * e3[i]
);
console.log(v); // [4, -2, 5]

27.12 Sistemas de coordenadas

Las componentes de un vector dependen de los ejes elegidos. En matemáticas suele usarse x hacia la derecha e y hacia arriba. En muchas interfaces gráficas, y crece hacia abajo.

Antes de programar transformaciones conviene documentar la orientación y las unidades de cada eje.

27.13 Conversión de coordenadas cartesianas a pantalla

Para dibujar un punto cartesiano en una pantalla con origen visual (o_x, o_y), se traslada el origen y se invierte el eje y.

function aPantalla([x, y], [origenX, origenY], escala = 1) {
  return [origenX + x * escala, origenY - y * escala];
}

console.log(aPantalla([3, 2], [400, 300], 20)); // [460, 260]

La escala convierte las unidades matemáticas en píxeles.

27.14 Rectas mediante puntos y vectores

Una recta puede describirse con un punto inicial p₀ y un vector director v:

La misma expresión funciona en ℝ² y ℝ³.

function puntoEnRecta(origen, direccion, t) {
  return origen.map((coordenada, i) => coordenada + t * direccion[i]);
}

console.log(puntoEnRecta([1, 2, 3], [2, 0, -1], 4)); // [9, 2, -1]

27.15 Planos mediante vectores

Un plano en ℝ³ puede describirse usando un punto p₀ y dos vectores directores no paralelos u y v:

function puntoEnPlano(origen, u, v, s, t) {
  return origen.map(
    (coordenada, i) => coordenada + s * u[i] + t * v[i]
  );
}

const origen = [0, 0, 1];
console.log(puntoEnPlano(origen, [1, 0, 0], [0, 1, 0], 3, -2));
// [3, -2, 1]

27.16 Representación en JavaScript

Los arreglos facilitan los algoritmos genéricos; los objetos con propiedades nombradas pueden resultar más legibles en código específicamente 2D o 3D.

const comoArreglo = [3, -1, 5];
const comoObjeto = { x: 3, y: -1, z: 5 };

function objetoAArreglo({ x, y, z }) {
  return [x, y, z];
}

console.log(objetoAArreglo(comoObjeto));
console.log(comoArreglo);

Una aplicación debe adoptar una convención uniforme para evitar conversiones y errores innecesarios.

27.17 Validación de vectores

Antes de operar conviene comprobar la dimensión y que todas las componentes sean números finitos.

function esVector(vector, dimension) {
  return Array.isArray(vector) &&
    vector.length === dimension &&
    vector.every(Number.isFinite);
}

console.log(esVector([1, 2], 2));        // true
console.log(esVector([1, NaN, 3], 3));   // false
console.log(esVector([1, 2, 3], 2));     // false

27.18 Aplicaciones y errores frecuentes

Los vectores 2D y 3D aparecen en gráficos, videojuegos, robótica, física, mapas, animación, modelado y visión por computadora.

Errores habituales:

• Confundir una posición con un desplazamiento.
• Calcular AB como A − B en lugar de B − A.
• Combinar vectores de diferentes dimensiones.
• Alterar el orden de las componentes.
• Ignorar que el eje y de la pantalla puede crecer hacia abajo.
• Mezclar sistemas de coordenadas o unidades sin convertirlos.

27.19 Qué debes recordar de este tema

• Un vector del plano tiene dos componentes y uno del espacio tiene tres.
• Un punto indica posición; un vector representa dirección y desplazamiento.
• El vector de A a B se calcula como B − A.
• El extremo de un desplazamiento es A + v.
• Los vectores libres son iguales cuando coinciden sus componentes.
• Los vectores canónicos indican las direcciones de los ejes.
• Las componentes dependen del sistema de coordenadas elegido.
• Los arreglos y objetos son representaciones útiles en JavaScript.

27.20 Conclusión

Las coordenadas convierten direcciones y desplazamientos geométricos en datos que un programa puede manipular. El mismo razonamiento funciona en el plano, en el espacio y, de forma abstracta, en dimensiones mayores.

En el próximo tema estudiaremos las operaciones con vectores y su interpretación algebraica y geométrica.