Redondeo y truncamiento

01 · Punto de partida

Reducir cifras también es tomar una decisión

Una pantalla pequeña muestra dos decimales, una factura trabaja con centavos y un informe resume mediciones con una cantidad limitada de cifras. En todos estos casos transformamos un número en otro que usa una resolución más gruesa.

Por ejemplo, a partir de 3.141592 podemos producir 3.14. Pero debemos aclarar cómo:

• ¿simplemente descartamos las cifras posteriores?
• ¿elegimos el valor con dos decimales más cercano?
• ¿qué ocurre con los números negativos?
• ¿modificamos el valor usado para calcular o solo su presentación?
• ¿qué error máximo introduce la reducción?

02 · Valor posicional

Elegir la posición que se conserva

En el sistema decimal, cada posición representa una potencia de 10. A la derecha del separador aparecen décimos, centésimos, milésimos y así sucesivamente.

Para conservar dos decimales de 12.3456, la posición retenida es el 4 de los centésimos. La cifra siguiente, 5, decide qué ocurre al redondear:

03 · Descartar sin compensar

Truncamiento

Truncar a una cantidad de decimales significa eliminar todas las cifras posteriores sin modificar la última conservada.

Para números positivos, el resultado se desplaza hacia abajo. Para números negativos, se desplaza hacia arriba, es decir, hacia cero:

Si conservamos d decimales, el paso entre valores representables es 10⁻ᵈ. Para datos positivos truncados, el error absoluto es menor que ese paso.

04 · Elegir el más cercano

Redondeo al valor más próximo

Para redondear a d decimales, observamos la primera cifra que se descartará:

• si está entre 0 y 4, la última cifra conservada no cambia;
• si está entre 5 y 9, se incrementa la última cifra conservada;
• si el incremento produce 10, se propaga un acarreo hacia la izquierda.

Salvo decisiones especiales en los empates exactos, el error absoluto del redondeo al más cercano no supera la mitad del paso. A dos decimales, queda como máximo alrededor de 0.005.

05 · Cuando hay dos vecinos iguales

Reglas para los empates

Un valor exactamente a mitad de camino, como 2.5 al redondear a enteros, está a la misma distancia de 2 y 3. Se necesita una política adicional.

El redondeo al par —también llamado bancario— reparte los empates entre incrementos y decrementos, reduciendo ciertos sesgos en grandes conjuntos de datos.

JavaScript usa para Math.round una regla equivalente a elegir el entero hacia +∞ en el empate:

console.log(Math.round(2.5));  // 3
console.log(Math.round(3.5));  // 4
console.log(Math.round(-2.5)); // -2
console.log(Math.round(-3.5)); // -3

Por eso no debemos asumir una regla de empates sin revisar las especificaciones del lenguaje, la biblioteca o el dominio.

06 · Consecuencias distintas

Comparar truncamiento y redondeo

Para 12.3456 a dos decimales:

Las diferencias respecto del valor original son 0.0056 y 0.0044, respectivamente. En este caso el redondeo queda más cerca.

“Redondear” no siempre es preferible: algunas reglas financieras, visualizaciones o algoritmos especifican explícitamente truncamiento, piso o techo. Lo correcto depende del contrato del problema.

07 · Llevar la posición a unidades

Multiplicar, operar y volver a dividir

Las funciones de JavaScript operan sobre enteros. Para trabajar con d decimales usamos un factor 10ᵈ:

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

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

console.log(truncarDecimales(12.3456, 2));   // 12.34
console.log(redondearDecimales(12.3456, 2)); // 12.35

El patrón es útil, pero hereda las limitaciones de los números binarios. Multiplicar por una potencia de 10 no convierte mágicamente todos los decimales en valores exactos.

Piso y techo

const valor = -2.81;

console.log(Math.trunc(valor)); // -2, hacia cero
console.log(Math.floor(valor)); // -3, hacia -Infinity
console.log(Math.ceil(valor));  // -2, hacia +Infinity
console.log(Math.round(valor)); // -3, entero más cercano

08 · Dos formas de contar

Decimales y cifras significativas

Las cifras decimales cuentan posiciones a la derecha del separador. Las cifras significativas comienzan en el primer dígito distinto de cero y expresan la resolución relativa del número.

Redondear 0.004567 a dos decimales elimina toda la información visible; conservar dos cifras significativas mantiene 4 y 6. La elección depende de si importa una resolución absoluta o proporcional.

JavaScript ofrece toPrecision para formatear una cantidad de cifras significativas:

console.log((1234.56).toPrecision(2)); // "1.2e+3"
console.log((0.004567).toPrecision(2)); // "0.0046"

09 · El decimal almacenado puede ser otro

Sorpresas de punto flotante

Muchos decimales no tienen una representación binaria finita. El valor escrito como 1.005 puede almacenarse apenas por debajo del número decimal ideal. Entonces:

console.log(Math.round(1.005 * 100) / 100); // 1
console.log((1.005).toFixed(2));            // "1.00"
console.log(1.005 * 100);                   // 100.49999999999999

El algoritmo redondea correctamente el valor binario que recibió, pero ese valor quedó del lado inferior del empate decimal.

Añadir Number.EPSILON resuelve algunos ejemplos positivos pequeños, pero no constituye una solución universal para todas las magnitudes, signos y reglas. Cuando el decimal exacto es obligatorio —por ejemplo, dinero— conviene trabajar con unidades enteras mínimas o usar una biblioteca decimal.

10 · Exploración

Laboratorio: reducir decimales

Ingresá un valor, elegí la cantidad de decimales y compará truncamiento, redondeo, piso y techo. La recta muestra la grilla de valores representables con esa resolución.

Los marcadores violetas forman la grilla decimal. El punto dorado es el valor original y el coral, el resultado del procedimiento seleccionado.

Preguntas para explorar

1. Probá 12.344 y 12.346 a dos decimales. ¿Cuándo coinciden truncamiento y redondeo?
2. Ingresá −12.3456 y compará truncamiento, piso y techo.
3. Usá 7.999 con dos decimales. ¿Qué procedimiento produce 8?
4. Probá 1.005 con dos decimales y relacioná el resultado con su representación binaria.

11 · Valor y texto

Formatear no siempre significa modificar el cálculo

toFixed produce una cadena con una cantidad fija de decimales:

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

console.log(texto);        // "12.30"
console.log(typeof texto); // "string"
console.log(valor);        // 12.3

El valor original no cambia. Esto es adecuado cuando queremos presentar una salida sin reducir prematuramente la precisión de cálculos posteriores.

Para respetar convenciones regionales, Intl.NumberFormat separa presentación y aritmética:

const formato = new Intl.NumberFormat("es-AR", {
  minimumFractionDigits: 2,
  maximumFractionDigits: 2
});

console.log(formato.format(1234.5)); // "1.234,50"

Si el dato reducido debe intervenir en una regla de negocio, la política debe implementarse y documentarse explícitamente. Si solo cambia cómo se ve, conviene conservar el número original.

12 · Comprensión

Confusiones frecuentes

13 · Práctica guiada

Ejercicios de comprensión

Ejercicio 1: aplicar ambos procedimientos

Truncá y redondeá a tres decimales los valores 5.67849, 5.67851 y −5.67851.

Ejercicio 2: cota del error

¿Qué error absoluto máximo introducen el truncamiento y el redondeo al cercano cuando se conservan cuatro decimales?

Ejercicio 3: significativas

Redondeá 98765 y 0.0098765 a tres cifras significativas.

Ejercicio 4: implementar procedimientos

Creá una función que reciba un número, una cantidad de decimales y uno de los modos trunc, round, floor o ceil.

function reducir(valor, decimales, modo) {
  if (!Number.isFinite(valor) || !Number.isInteger(decimales)) {
    throw new TypeError("Valor o cantidad de decimales inválidos");
  }
  if (decimales < 0 || decimales > 12) {
    throw new RangeError("Decimales fuera del rango admitido");
  }

  const operaciones = {
    trunc: Math.trunc,
    round: Math.round,
    floor: Math.floor,
    ceil: Math.ceil
  };
  const operacion = operaciones[modo];
  if (!operacion) throw new RangeError("Modo desconocido");

  const factor = 10 ** decimales;
  return operacion(valor * factor) / factor;
}

console.log(reducir(-2.819, 2, "trunc")); // -2.81
console.log(reducir(-2.819, 2, "floor")); // -2.82

14 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos la precisión de los números en JavaScript: cómo funciona el punto flotante, qué valores pueden representarse exactamente y por qué aparecen resultados inesperados.