34. Aproximación, redondeo y errores numéricos

34.1 Introducción

No todos los cálculos producen resultados exactos. Algunas raíces, divisiones y operaciones con decimales generan valores aproximados.

En programación, estos detalles importan porque pueden afectar comparaciones, reportes, cálculos financieros, gráficos y validaciones.

Este tema reúne ideas ya vistas sobre decimales y precisión, y las organiza alrededor de aproximación, redondeo y errores numéricos.

34.2 Qué es una aproximación

Una aproximación es un valor cercano al valor real o exacto. Se usa cuando el valor exacto es infinito, difícil de representar o innecesariamente detallado.

console.log(Math.PI);
console.log(Math.sqrt(2));

JavaScript muestra aproximaciones decimales de esos valores.

34.3 Redondeo al entero más cercano

Math.round() redondea un número al entero más cercano.

console.log(Math.round(3.2));
console.log(Math.round(3.5));
console.log(Math.round(3.8));

El redondeo se usa cuando necesitamos mostrar o trabajar con valores enteros.

34.4 Redondear hacia abajo y hacia arriba

Math.floor() redondea hacia abajo y Math.ceil() redondea hacia arriba.

const valor = 4.2;

console.log(Math.floor(valor));
console.log(Math.ceil(valor));

Estas funciones son útiles para páginas, lotes, cantidades mínimas o máximas y distribución de elementos.

34.5 Truncamiento

Truncar significa quitar la parte decimal sin redondear. En JavaScript se usa Math.trunc().

console.log(Math.trunc(7.9));
console.log(Math.trunc(7.1));
console.log(Math.trunc(-7.9));

Truncar no es lo mismo que redondear. Solo elimina los decimales.

34.6 Redondear a cierta cantidad de decimales

Podemos redondear a dos decimales multiplicando por 100, aplicando Math.round() y dividiendo por 100.

function redondear(valor, decimales) {
  const factor = 10 ** decimales;
  return Math.round(valor * factor) / factor;
}

console.log(redondear(12.3456, 2));
console.log(redondear(12.3456, 3));

34.7 toFixed()

toFixed() devuelve una cadena con una cantidad fija de decimales. Es útil para mostrar, pero no debe confundirse con un número.

const valor = 12.3;
const texto = valor.toFixed(2);

console.log(texto);
console.log(typeof texto);

Si necesitamos seguir calculando, podemos convertir el texto con Number().

34.8 Error absoluto

El error absoluto mide la diferencia directa entre el valor aproximado y el valor real o esperado.

const real = Math.PI;
const aproximado = 3.14;
const error = Math.abs(aproximado - real);

console.log(error);

34.9 Error relativo

El error relativo compara el error absoluto con el valor real. Suele expresarse como porcentaje.

const real = Math.PI;
const aproximado = 3.14;
const errorAbsoluto = Math.abs(aproximado - real);
const errorRelativo = errorAbsoluto / real * 100;

console.log(errorRelativo);

34.10 Errores de punto flotante

Algunos decimales no pueden representarse exactamente en binario, por eso ciertos cálculos producen resultados inesperados.

console.log(0.1 + 0.2);
console.log(0.3);
console.log(0.1 + 0.2 === 0.3);

El resultado está muy cerca de 0.3, pero no es exactamente igual.

34.11 Comparar con tolerancia

Para comparar decimales, se suele verificar si la diferencia es menor que una tolerancia.

function casiIguales(a, b, tolerancia) {
  return Math.abs(a - b) < tolerancia;
}

console.log(casiIguales(0.1 + 0.2, 0.3, 0.0000001));

La tolerancia debe elegirse según la escala y el contexto del problema.

34.12 Acumulación de errores

Un error muy pequeño puede acumularse si repetimos una operación muchas veces.

let total = 0;

for (let i = 0; i < 10; i++) {
  total = total + 0.1;
}

console.log(total);

Cuando sea posible, una alternativa es trabajar con enteros escalados.

let totalDecimas = 0;

for (let i = 0; i < 10; i++) {
  totalDecimas = totalDecimas + 1;
}

console.log(totalDecimas / 10);

34.13 Aplicación: dinero y centavos

Para cálculos simples con dinero, suele ser mejor trabajar en centavos como enteros y convertir al final para mostrar.

const precioCentavos = 1999;
const cantidad = 3;
const totalCentavos = precioCentavos * cantidad;

console.log(totalCentavos);
console.log((totalCentavos / 100).toFixed(2));

Esto evita muchos problemas de precisión al sumar importes decimales.

34.14 Errores comunes

• Comparar decimales con igualdad exacta después de cálculos.
• Usar toFixed() y olvidar que devuelve texto.
• Redondear demasiado pronto y luego seguir calculando.
• Mostrar muchos decimales sin que tengan significado real.
• Confundir truncar con redondear.
• No elegir una tolerancia adecuada para el problema.

const valor = 12.999;

console.log(Math.round(valor));
console.log(Math.trunc(valor));

34.15 Qué debes recordar de este tema

• Una aproximación es un valor cercano al valor exacto.
• Redondear, truncar, redondear hacia arriba y hacia abajo son operaciones diferentes.
• toFixed() sirve para mostrar valores con decimales fijos, pero devuelve texto.
• El error absoluto mide diferencia directa.
• El error relativo mide el error en relación con el valor real.
• Los decimales en JavaScript pueden tener errores de punto flotante.
• Para comparar decimales conviene usar tolerancias.

34.16 Conclusión

Aproximar y redondear son decisiones necesarias al trabajar con números reales en una computadora. Comprender los errores numéricos ayuda a evitar fallas sutiles en comparaciones, reportes y cálculos importantes.

En el próximo tema estudiaremos matemática financiera básica para programación, donde el manejo cuidadoso de redondeos e importes será especialmente importante.