23. Aplicaciones: desplazamientos, velocidades y fuerzas

23.1 Del vector abstracto al estado físico

Una misma estructura {x, y} puede almacenar posición, velocidad, aceleración o fuerza, pero esas magnitudes no son intercambiables. Cada una tiene unidades, significado y reglas físicas propias.

23.2 Posición y desplazamiento

La posición localiza un cuerpo. El desplazamiento es la diferencia entre la posición final y la inicial:

const restar = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });

const inicial = { x: 2, y: -1 };
const final = { x: 8, y: 3 };
const desplazamiento = restar(final, inicial);
console.log("Desplazamiento:", desplazamiento, "m");
console.log("Módulo:", Math.hypot(desplazamiento.x, desplazamiento.y), "m");

23.3 Distancia recorrida no es desplazamiento

La distancia suma las longitudes de todos los tramos y es escalar. El desplazamiento solo conecta los extremos y es vectorial. Si un móvil regresa al inicio, su desplazamiento es cero aunque haya recorrido una distancia considerable.

const puntos = [{x:0,y:0}, {x:3,y:0}, {x:3,y:4}, {x:0,y:0}];
let distancia = 0;
for (let i = 1; i < puntos.length; i++) {
  distancia += Math.hypot(
    puntos[i].x - puntos[i-1].x,
    puntos[i].y - puntos[i-1].y
  );
}
const primero = puntos[0], ultimo = puntos.at(-1);
const desplazamiento = {x:ultimo.x-primero.x, y:ultimo.y-primero.y};
console.log("Distancia:", distancia, "m");
console.log("Desplazamiento:", desplazamiento, "m");

23.4 Velocidad media

La velocidad media es el desplazamiento dividido por el intervalo temporal. Apunta desde la posición inicial hacia la final y no describe los giros intermedios.

function velocidadMedia(inicial, final, dt) {
  if (!(dt > 0)) throw new RangeError("dt debe ser positivo");
  return {
    x: (final.x - inicial.x) / dt,
    y: (final.y - inicial.y) / dt
  };
}

const v = velocidadMedia({x:1,y:2}, {x:7,y:-1}, 3);
console.log("Velocidad media:", v, "m/s");

23.5 Velocidad instantánea y rapidez

La velocidad instantánea es tangente a la trayectoria y contiene dirección y sentido. La rapidez es su módulo y no puede ser negativa.

const rapidez = v => Math.hypot(v.x, v.y);
const direccion = v => {
  const m = rapidez(v);
  return m === 0 ? null : { x: v.x / m, y: v.y / m };
};

const velocidad = { x: -6, y: 8 };
console.log("Rapidez:", rapidez(velocidad), "m/s");
console.log("Dirección:", direccion(velocidad));

23.6 Movimiento con velocidad constante

Si la velocidad no cambia, la posición luego de un intervalo dt se obtiene sumando el desplazamiento v·dt.

const sumar = (a,b) => ({x:a.x+b.x, y:a.y+b.y});
const escalar = (v,k) => ({x:v.x*k, y:v.y*k});

const posicion = { x: 4, y: 1 };
const velocidad = { x: 2, y: -0.5 };
const siguiente = sumar(posicion, escalar(velocidad, 1.5));
console.log("Posición después de 1,5 s:", siguiente, "m");

23.7 Aceleración

La aceleración mide el cambio de velocidad por unidad de tiempo. Puede modificar el módulo, la dirección o ambos. Un móvil que gira con rapidez constante también está acelerado.

function aceleracionMedia(vi, vf, dt) {
  if (!(dt > 0)) throw new RangeError("dt debe ser positivo");
  return { x: (vf.x-vi.x)/dt, y: (vf.y-vi.y)/dt };
}

console.log(aceleracionMedia(
  {x:4,y:0}, {x:4,y:6}, 2
), "m/s²");

23.8 Integración numérica de Euler

Una simulación avanza en pasos pequeños. Euler semiexplícito actualiza primero la velocidad con la aceleración y después la posición con la nueva velocidad. Suele comportarse mejor que el Euler explícito para muchos sistemas mecánicos sencillos.

function avanzar(estado, aceleracion, dt) {
  const velocidad = {
    x: estado.velocidad.x + aceleracion.x * dt,
    y: estado.velocidad.y + aceleracion.y * dt
  };
  const posicion = {
    x: estado.posicion.x + velocidad.x * dt,
    y: estado.posicion.y + velocidad.y * dt
  };
  return { posicion, velocidad };
}

const estado = avanzar(
  {posicion:{x:0,y:0}, velocidad:{x:5,y:8}},
  {x:0,y:-9.8}, 0.1
);
console.log(estado);

23.9 Fuerza resultante

Varias fuerzas aplicadas al mismo cuerpo se combinan mediante suma vectorial. La resultante determina la aceleración; las fuerzas no se sustituyen por sus módulos.

function sumarFuerzas(fuerzas) {
  return fuerzas.reduce(
    (total, f) => ({x:total.x+f.x, y:total.y+f.y}),
    {x:0, y:0}
  );
}

const fuerzas = [
  {x:12,y:0}, {x:-3,y:4}, {x:0,y:-7}
];
console.log("Resultante:", sumarFuerzas(fuerzas), "N");

23.10 Segunda ley de Newton

Para masa constante, la aceleración es la fuerza resultante dividida por la masa. La masa es escalar y debe ser positiva.

function aceleracionPorFuerza(fuerza, masa) {
  if (!(masa > 0) || !Number.isFinite(masa)) {
    throw new RangeError("La masa debe ser positiva y finita");
  }
  return { x: fuerza.x / masa, y: fuerza.y / masa };
}

console.log(aceleracionPorFuerza({x:10,y:-19.6}, 2), "m/s²");

Duplicar la fuerza duplica la aceleración; duplicar la masa la reduce a la mitad.

23.11 Peso y gravedad

Cerca de la superficie terrestre podemos aproximar la aceleración gravitatoria como g = (0, −9,8) m/s² si y apunta hacia arriba. El peso resulta P = mg.

const gravedad = { x: 0, y: -9.8 };
const peso = (masa, g=gravedad) => ({x:masa*g.x, y:masa*g.y});

for (const masa of [0.5, 2, 10]) {
  console.log(`${masa} kg:`, peso(masa), "N");
}

En ausencia de resistencia del aire, todos los cuerpos tienen la misma aceleración gravitatoria aunque su peso sea distinto, porque al dividir mg por m la masa se cancela.

23.12 Fuerza normal

Una superficie impide que el cuerpo la atraviese mediante una fuerza normal, perpendicular al contacto. En un piso horizontal sin aceleración vertical, la normal equilibra el peso. No siempre es igual al peso: cambia en planos inclinados, ascensores o curvas.

const punto = (a,b) => a.x*b.x + a.y*b.y;
const escalar = (v,k) => ({x:v.x*k, y:v.y*k});

function componenteNormal(fuerza, normalUnitaria) {
  return escalar(normalUnitaria, punto(fuerza, normalUnitaria));
}

const peso = {x:0,y:-98};
const normalPlano = {x:-0.5,y:Math.sqrt(3)/2};
console.log("Componente normal del peso:", componenteNormal(peso, normalPlano));

23.13 Rozamiento y resistencia

Un modelo simple de rozamiento cinético tiene módulo μN y dirección opuesta al deslizamiento. Una resistencia viscosa puede modelarse como Fd = −kv.

function resistenciaLineal(velocidad, k) {
  if (k < 0) throw new RangeError("k no puede ser negativo");
  return { x: -k * velocidad.x, y: -k * velocidad.y };
}

const velocidad = {x:6,y:-2};
console.log("Resistencia:", resistenciaLineal(velocidad, 0.5), "N");

La resistencia lineal es una aproximación útil a bajas velocidades. Para otros regímenes puede depender del cuadrado de la rapidez.

23.14 Fuerzas en una dirección elegida

El producto escalar permite conocer cuánto contribuye una fuerza a lo largo de una dirección unitaria. Esto es útil para analizar movimiento sobre rieles, rampas o ejes locales.

const punto = (a,b) => a.x*b.x + a.y*b.y;
const fuerza = {x:10,y:-6};
const eje = {x:Math.cos(Math.PI/6), y:Math.sin(Math.PI/6)};
const componenteEscalar = punto(fuerza, eje);
const componenteVectorial = {
  x:eje.x*componenteEscalar,
  y:eje.y*componenteEscalar
};
console.log("Componente escalar:", componenteEscalar, "N");
console.log("Componente vectorial:", componenteVectorial, "N");

23.15 Equilibrio

Si la fuerza resultante es cero, la aceleración es cero. Eso no significa necesariamente reposo: el cuerpo puede conservar una velocidad constante.

const fuerzas = [{x:8,y:2}, {x:-3,y:4}, {x:-5,y:-6}];
const resultante = fuerzas.reduce(
  (r,f) => ({x:r.x+f.x,y:r.y+f.y}), {x:0,y:0}
);
const tolerancia = 1e-10;
const equilibrio = Math.hypot(resultante.x,resultante.y) <= tolerancia;
console.log("Resultante:", resultante);
console.log("¿Equilibrio?", equilibrio);

23.16 Trabajo de una fuerza

El trabajo realizado por una fuerza constante durante un desplazamiento es su producto escalar. Solo contribuye la componente paralela al movimiento.

const trabajo = (fuerza, desplazamiento) =>
  fuerza.x*desplazamiento.x + fuerza.y*desplazamiento.y;

console.log("Fuerza a favor:", trabajo({x:10,y:0},{x:3,y:0}), "J");
console.log("Fuerza perpendicular:", trabajo({x:0,y:10},{x:3,y:0}), "J");
console.log("Fuerza opuesta:", trabajo({x:-10,y:0},{x:3,y:0}), "J");

23.17 Movimiento de proyectil

Sin resistencia del aire, la componente horizontal de velocidad permanece constante y la vertical cambia por gravedad. Para condiciones iniciales conocidas existe una solución analítica:

function proyectil(posicion, velocidad, gravedad, t) {
  return {
    x: posicion.x + velocidad.x*t + 0.5*gravedad.x*t*t,
    y: posicion.y + velocidad.y*t + 0.5*gravedad.y*t*t
  };
}

for (const t of [0, 0.5, 1, 1.5]) {
  console.log(`t=${t}:`, proyectil(
    {x:0,y:0}, {x:8,y:10}, {x:0,y:-9.8}, t
  ));
}

La solución analítica sirve para verificar una integración numérica bajo estas condiciones ideales.

23.18 Unidades y paso temporal

Si posición está en metros, velocidad debe estar en metros por segundo, aceleración en metros por segundo cuadrado y dt en segundos. Usar milisegundos directamente multiplica el avance por mil.

const anteriorMs = 1250;
const actualMs = 1266.67;
const dtSegundos = (actualMs - anteriorMs) / 1000;
console.log("dt:", dtSegundos, "s");
console.log("Desplazamiento a 3 m/s:", 3 * dtSegundos, "m");

Unidades explícitas en nombres como tiempoMs, dtS o velocidadMps reducen errores.

23.19 Laboratorio de fuerzas y movimiento

Aplicá una fuerza a un cuerpo y observá la relación F = ma. La gravedad y la resistencia son opcionales. Las flechas muestran fuerza resultante, velocidad y aceleración; la trayectoria queda registrada.

23.20 Del modelo a una arquitectura

Una simulación mantenible separa responsabilidades: el estado almacena posición y velocidad; el modelo calcula fuerzas; el integrador avanza el estado; la vista transforma coordenadas y dibuja; los controles modifican parámetros.

Esta separación permite probar la física sin Canvas y cambiar la representación visual sin alterar las ecuaciones. También facilita reemplazar Euler por otro integrador.

23.21 Errores frecuentes

• Confundir posición con desplazamiento o distancia con módulo del desplazamiento.
• Confundir rapidez escalar con velocidad vectorial.
• Sumar magnitudes con unidades incompatibles.
• Sumar módulos de fuerzas en vez de componentes.
• Suponer que fuerza resultante nula implica velocidad nula.
• Aplicar gravedad como fuerza sin multiplicarla por la masa.
• Usar milisegundos como si fueran segundos.
• Actualizar posición sin actualizar primero la velocidad.
• Elegir un paso temporal demasiado grande para el fenómeno.
• Interpretar un modelo simplificado como descripción universal.

23.22 Ejercicio integrador

Simulá durante dos segundos un cuerpo de 2 kg que parte del reposo y recibe las fuerzas (10, 0) N, (0, −19,6) N y (−2, 3,6) N. Usá Euler semiexplícito con dt = 0,5 s.

const sumar = (a,b) => ({x:a.x+b.x,y:a.y+b.y});
const escalar = (v,k) => ({x:v.x*k,y:v.y*k});
const fuerzas = [{x:10,y:0},{x:0,y:-19.6},{x:-2,y:3.6}];
const resultante = fuerzas.reduce(sumar, {x:0,y:0});
const masa = 2, dt = 0.5;
const aceleracion = escalar(resultante, 1/masa);
let posicion = {x:0,y:0}, velocidad = {x:0,y:0};

for (let tiempo = dt; tiempo <= 2; tiempo += dt) {
  velocidad = sumar(velocidad, escalar(aceleracion, dt));
  posicion = sumar(posicion, escalar(velocidad, dt));
  console.log(`t=${tiempo}s`, {posicion, velocidad});
}
console.log("Fuerza resultante:", resultante, "N");
console.log("Aceleración:", aceleracion, "m/s²");

23.23 Ideas para recordar

• El desplazamiento es posición final menos posición inicial.
• La distancia depende de toda la trayectoria; el desplazamiento, solo de sus extremos.
• Velocidad y aceleración describen cambios temporales vectoriales.
• La fuerza resultante es la suma vectorial de todas las fuerzas externas.
• La segunda ley conecta fuerza, masa y aceleración.
• Una fuerza perpendicular al desplazamiento no realiza trabajo.
• La integración numérica aproxima el movimiento mediante pasos temporales.
• Las unidades coherentes y un dt adecuado son parte del algoritmo.
• Modelo, integración y visualización deben permanecer separados.

En el próximo tema integraremos todo el curso en un laboratorio vectorial interactivo con herramientas de construcción, medición y simulación.