31. Producto escalar

31.1 Introducción

La suma de vectores produce otro vector, pero no todas las operaciones vectoriales tienen ese resultado. El producto escalar, también llamado producto punto, transforma dos vectores de igual dimensión en un escalar.

Su valor reúne información sobre las magnitudes de los vectores y el ángulo entre ellos.

31.2 Definición algebraica

Para u = (u₁, ..., u_n) y v = (v₁, ..., v_n):

Se multiplican las componentes correspondientes y luego se suman todos los productos.

function productoEscalar(u, v) {
  if (u.length !== v.length) throw new Error("Dimensiones incompatibles");
  return u.reduce((suma, valor, i) => suma + valor * v[i], 0);
}

console.log(productoEscalar([1, 2, 3], [4, -1, 2])); // 8

31.3 Ejemplo en ℝ²

Sean u = (3, 4) y v = (2, −1):

const u = [3, 4];
const v = [2, -1];
const resultado = u[0] * v[0] + u[1] * v[1];

console.log(resultado); // 2

31.4 Ejemplo en ℝ³

Sean u = (1, −2, 3) y v = (4, 0, −1):

const u = [1, -2, 3];
const v = [4, 0, -1];
const productos = u.map((valor, i) => valor * v[i]);
const punto = productos.reduce((suma, valor) => suma + valor, 0);

console.log(productos); // [4, 0, -3]
console.log(punto);     // 1

31.5 Producto escalar y producto de Hadamard

Ambas operaciones comienzan multiplicando componentes, pero producen resultados diferentes:

const u = [2, 3, 4];
const v = [5, -1, 0.5];
const hadamard = u.map((valor, i) => valor * v[i]);
const escalar = hadamard.reduce((suma, valor) => suma + valor, 0);

console.log(hadamard); // [10, -3, 2]
console.log(escalar);  // 9

31.6 Propiedades del producto escalar

const dot = (u, v) => u.reduce((s, x, i) => s + x * v[i], 0);
const u = [1, 3];
const v = [2, -4];

console.log(dot(u, v)); // -10
console.log(dot(v, u)); // -10

31.7 Relación con la norma

El producto de un vector consigo mismo es la suma de los cuadrados de sus componentes:

const v = [2, -3, 6];
const productoConsigoMismo = v.reduce((suma, valor) => suma + valor * valor, 0);

console.log(productoConsigoMismo);       // 49
console.log(Math.sqrt(productoConsigoMismo)); // 7

31.8 Interpretación geométrica

Si θ es el ángulo entre dos vectores no nulos:

Esta fórmula explica que el producto escalar mide la alineación. Las magnitudes amplifican el resultado y el coseno determina su signo.

31.9 Signo del producto escalar

const dot = (u, v) => u.reduce((s, x, i) => s + x * v[i], 0);
const referencia = [1, 0];

console.log(dot(referencia, [2, 1]));  // positivo
console.log(dot(referencia, [0, 3]));  // cero
console.log(dot(referencia, [-2, 1])); // negativo

31.10 Ortogonalidad

Dos vectores no nulos son ortogonales si su producto escalar es cero. En ℝ² y ℝ³ esto significa que forman un ángulo recto.

function sonOrtogonales(u, v, tolerancia = 1e-10) {
  const producto = u.reduce((suma, valor, i) => suma + valor * v[i], 0);
  return Math.abs(producto) <= tolerancia;
}

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

El vector cero tiene producto escalar cero con todos los vectores, pero no define un ángulo ni una dirección.

31.11 Calcular el ángulo entre vectores

Despejando el coseno:

function anguloEntre(u, v, tolerancia = 1e-12) {
  if (u.length !== v.length) throw new Error("Dimensiones incompatibles");
  const normaU = Math.hypot(...u);
  const normaV = Math.hypot(...v);
  if (normaU <= tolerancia || normaV <= tolerancia) return null;

  const producto = u.reduce((suma, valor, i) => suma + valor * v[i], 0);
  const coseno = Math.max(-1, Math.min(1, producto / (normaU * normaV)));
  return Math.acos(coseno);
}

const radianes = anguloEntre([1, 0], [0, 1]);
console.log(radianes * 180 / Math.PI); // 90

31.12 Vectores unitarios y coseno

Si u y v son unitarios, sus normas valen 1 y la fórmula se simplifica:

El resultado queda siempre entre −1 y 1: 1 indica la misma dirección, 0 perpendicularidad y −1 direcciones opuestas.

const grados = 60;
const theta = grados * Math.PI / 180;
const u = [1, 0];
const v = [Math.cos(theta), Math.sin(theta)];
const producto = u[0] * v[0] + u[1] * v[1];

console.log(producto); // aproximadamente 0.5

31.13 Aplicación: campo de visión

Para saber si un objetivo está dentro de un cono de visión, se compara el producto entre la dirección frontal unitaria y la dirección unitaria hacia el objetivo con el coseno del semiángulo permitido.

function estaEnCampoVisual(frente, haciaObjetivo, semiAnguloGrados) {
  const limite = Math.cos(semiAnguloGrados * Math.PI / 180);
  const alineacion = frente.reduce(
    (suma, valor, i) => suma + valor * haciaObjetivo[i],
    0
  );
  return alineacion >= limite;
}

const frente = [1, 0];
const haciaObjetivo = [Math.sqrt(3) / 2, 0.5]; // 30°
console.log(estaEnCampoVisual(frente, haciaObjetivo, 45)); // true

31.14 Aplicación: iluminación difusa

En el modelo difuso de Lambert, la intensidad depende de la alineación entre la normal unitaria de una superficie y la dirección unitaria hacia la luz.

function intensidadDifusa(normal, haciaLuz) {
  const producto = normal.reduce(
    (suma, valor, i) => suma + valor * haciaLuz[i],
    0
  );
  return Math.max(0, producto);
}

console.log(intensidadDifusa([0, 1, 0], [0.6, 0.8, 0])); // 0.8

31.15 Aplicación: trabajo mecánico

Si una fuerza constante F produce un desplazamiento d, el trabajo es:

Solo contribuye la componente de la fuerza alineada con el movimiento.

const fuerza = [10, 0];       // newtons
const desplazamiento = [3, 4]; // metros
const trabajo = fuerza.reduce(
  (suma, valor, i) => suma + valor * desplazamiento[i],
  0
);

console.log(trabajo); // 30 joules

31.16 Aplicación: similitud coseno

La similitud coseno compara la orientación de vectores sin depender de su magnitud:

Se utiliza para comparar documentos, características y representaciones numéricas.

function similitudCoseno(u, v) {
  const normaU = Math.hypot(...u);
  const normaV = Math.hypot(...v);
  if (normaU === 0 || normaV === 0) return null;
  const punto = u.reduce((suma, valor, i) => suma + valor * v[i], 0);
  return punto / (normaU * normaV);
}

console.log(similitudCoseno([1, 1, 0], [2, 2, 0])); // aproximadamente 1

31.17 Implementación validada

Una función general debe exigir arreglos no vacíos, igual dimensión y componentes finitas.

function dot(u, v) {
  const validos = Array.isArray(u) && Array.isArray(v) &&
    u.length > 0 && u.length === v.length &&
    [...u, ...v].every(Number.isFinite);
  if (!validos) throw new Error("Vectores inválidos o incompatibles");
  return u.reduce((suma, valor, i) => suma + valor * v[i], 0);
}

console.log(dot([1, 2, 3, 4], [4, 3, 2, 1])); // 20

31.18 Precisión y errores frecuentes

Al calcular un ángulo, el cociente teórico pertenece a [−1, 1], pero el redondeo puede producir 1.0000000001. Antes de aplicar Math.acos() debe limitarse al intervalo válido.

Errores habituales:

• Devolver el vector de productos sin sumar sus componentes.
• Operar vectores de dimensiones diferentes.
• Confundir producto escalar y producto vectorial.
• Calcular un ángulo cuando uno de los vectores es cero.
• Suponer que un producto cero siempre define 90°, incluso con el vector cero.
• Usar el producto como coseno sin normalizar o dividir por las normas.
• No limitar el coseno antes de aplicar el arcocoseno.

31.19 Qué debes recordar de este tema

• El producto escalar multiplica componentes correspondientes y suma los resultados.
• Su resultado es un escalar.
• v · v = ||v||².
• u · v = ||u||||v|| cos θ.
• El signo indica si el ángulo es agudo, recto u obtuso.
• Dos vectores no nulos son ortogonales cuando su producto escalar es cero.
• Para vectores unitarios, el producto escalar es el coseno del ángulo.
• El ángulo no está definido si alguno de los vectores es cero.

31.20 Conclusión

El producto escalar conecta componentes algebraicas con orientación geométrica. Con una sola suma permite medir alineación, detectar perpendicularidad y recuperar el ángulo entre vectores.

En el próximo tema estudiaremos el producto vectorial, una operación tridimensional cuyo resultado es perpendicular a los dos vectores originales.