Dinero en código: centavos enteros o tipos decimales

Curso de números 4: int(19.99*100) dio 1998, BigDecimal 2.0 != 2.00, bcmul perdió los centavos, repartir redondeando falló en 32% y Decimal costó de 2.7x a 21x.

Serie: curso de números y dinero 4/6 (intermedio). Para ti si ya viste fallar un redondeo (clase 3) y ahora tienes que guardar precios, totalizar un carrito, repartir un gasto entre socios o convertir monedas sin que te reclamen un centavo. Al terminar sabrás cuándo usar centavos enteros y cuándo un tipo decimal, la trampa que esconde cada tipo decimal en Python, Java, C#, PHP y Swift, y tendrás una función de reparto que nunca pierde un centavo.

Los errores de dinero casi nunca son dramáticos: un reembolso con un centavo de menos, un CSV de la pasarela de pago que no cuadra con tu contabilidad, una factura de freelance en euros cobrada en pesos que no coincide con lo que depositó el banco. Esta clase es para quien tiene que arreglar eso y quiere reglas respaldadas por salidas reales, no por opiniones. Todo se ejecutó en una Mac con Apple Silicon (M1 Pro) con Python 3.9.6 (y 3.12 para comparar), Java 26, .NET 10.0.14, PHP 8.5.6 (bcmath, intl con ICU 78.3), Swift 6.4.2, SQLite 3.51.0 y el shell jsc de macOS. Los números van con punto decimal, como en el código; cómo mostrarlos con coma ("1.234,56" en España) es tema de la clase 5.

Por qué float es el recipiente equivocado para el dinero

La clase 1 mostró que 0.1 no tiene forma binaria exacta. Con dinero eso se convierte en centavos equivocados en cuanto conviertes o truncas:

# float_money.py
print("sum of ten 0.10 =", sum([0.10] * 10))
print("int(19.99 * 100) =", int(19.99 * 100))
print("round(19.99 * 100) =", round(19.99 * 100))
print("0.07 * 100 =", 0.07 * 100)
sum of ten 0.10 = 0.9999999999999999
int(19.99 * 100) = 1998
round(19.99 * 100) = 1999
0.07 * 100 = 7.000000000000001

int() trunca, y 19.99 * 100 queda apenas por debajo de 1999, así que un precio de 19.99 se volvió 1998 centavos. JavaScript imprimió 19.99*100 = 1998.9999999999998, y SQLite hizo lo mismo en una consulta: CAST(19.99*100 AS INTEGER) devolvió 1998. Convertir con round() funciona aquí, pero entonces la corrección depende de que todos lo recuerden en todas las capas.

Un detalle de SQLite nos sorprendió: sumar diez filas de 0.10 guardadas como REAL devolvió exactamente 1.0 en 3.51.0, mientras que el sum simple de Python imprimió 0.9999999999999999. Las versiones recientes de SQLite suman floats con más cuidado. Eso no vuelve seguro a REAL para dinero; solo mueve el error a otro lugar.

Opción 1: enteros en unidades mínimas

La regla robusta más simple: guarda cada monto como un número entero de la unidad mínima de la moneda. 19.99 EUR es 1999; 1,250.50 MXN es 125050; 15,000 CLP es 15000, porque el peso chileno no usa centavos. Sumar, restar y comparar es exacto, rápido e idéntico en todos los lenguajes y bases de datos.

¿Cuántos decimales tiene cada moneda? Se lo preguntamos a cuatro bibliotecas:

Moneda Java Currency .NET CultureInfo PHP NumberFormatter (ICU 78.3) jsc Intl
CLP 0 0 (es-CL) 0 0
COP 2 0 (es-CO) 0 2
EUR / MXN / USD 2 2 2 2
JPY / KRW 0 0 0 0
BHD 3 (no probado) (no probado) (no probado)

Currency.getDefaultFractionDigits() de Java sigue ISO 4217 (COP 2, BHD 3). .NET y PHP formatearon 1234.5 pesos colombianos sin decimales, $ 1.235, mientras que jsc imprimió $ 1.234,50. Y para euros en España, PHP mostró 1.234,50 € y jsc 1234,50 €, sin separador de miles. Así que no saques los decimales de un formateador de locale: ten tu propia tabla por código de moneda y úsala tanto para leer como para mostrar.

Un convertidor pequeño evita que el texto de entrada toque un float:

# cents.py
from decimal import Decimal

MINOR = {"JPY": 0, "KRW": 0, "CLP": 0, "USD": 2, "EUR": 2, "MXN": 2}

def to_minor(text, currency):
    """'19.99' USD -> 1999; '1500' JPY -> 1500. Refuses more digits than the currency has."""
    d = Decimal(text)
    scaled = d.scaleb(MINOR[currency])
    if scaled != scaled.to_integral_value():
        raise ValueError(f"{text} has more decimals than {currency} allows")
    return int(scaled)

def show(minor, currency):
    return f"{Decimal(minor).scaleb(-MINOR[currency]):.{MINOR[currency]}f} {currency}"

print(to_minor("19.99", "USD"), to_minor("1500", "JPY"), to_minor("12.5", "EUR"))
print(show(1999 * 3, "USD"), show(4500 * 3, "KRW"))
try:
    to_minor("100.5", "JPY")
except ValueError as e:
    print("ValueError:", e)
1999 1500 1250
59.97 USD 13500 KRW
ValueError: 100.5 has more decimals than JPY allows

La tabla MINOR incluye CLP con 0: un formulario chileno que recibe "15000.50" debe rechazarlo igual que el ejemplo de JPY. Los enteros también tienen límites (clase 2). Un entero con signo de 64 bits llega a unos 9.2 × 10^18 unidades, de sobra para precios, pero Number de JavaScript solo es exacto hasta 2^53. Si los montos viajan por JSON a un navegador, mándalos como texto o mantenlos pequeños.

Opción 2: tipos decimales, y la trampa de cada uno

Los centavos enteros no pueden guardar un IVA del 16% ni un precio unitario de 0.0123. Para esos pasos necesitas un tipo en base 10. Cada lenguaje tiene uno, y cada uno tiene su trampa.

Decimal de Python: créalo desde texto, nunca desde float.

# decimal_traps.py
import decimal
from decimal import Decimal, ROUND_HALF_UP

print("Decimal(0.1)   =", Decimal(0.1))
print("Decimal('0.1') =", Decimal("0.1"))
print("Decimal(0.1) * 3 == Decimal('0.3'):", Decimal(0.1) * 3 == Decimal("0.3"))
ctx = decimal.getcontext()
print("prec =", ctx.prec, "| rounding =", ctx.rounding)
print("Decimal(1) / 3 * 3 =", Decimal(1) / 3 * 3)
print("quantize 2.665 ->", Decimal("2.665").quantize(Decimal("0.01")),
      "| HALF_UP ->", Decimal("2.665").quantize(Decimal("0.01"), ROUND_HALF_UP))
ctx.traps[decimal.FloatOperation] = True      # make float leaks loud
try:
    Decimal(19.99)
except decimal.FloatOperation as e:
    print("FloatOperation trapped:", type(e).__name__)
Decimal(0.1)   = 0.1000000000000000055511151231257827021181583404541015625
Decimal('0.1') = 0.1
Decimal(0.1) * 3 == Decimal('0.3'): False
prec = 28 | rounding = ROUND_HALF_EVEN
Decimal(1) / 3 * 3 = 0.9999999999999999999999999999
quantize 2.665 -> 2.66 | HALF_UP -> 2.67
FloatOperation trapped: FloatOperation

Tres lecciones: Decimal(0.1) copia fielmente el error del float; el contexto por defecto redondea al par con 28 dígitos significativos, así que quantize sin regla da 2.66 y no 2.67; y la división sigue sin ser exacta. Activar la trampa FloatOperation hace que cualquier float que se cuele en un Decimal lance una excepción en vez de esconderse.

BigDecimal de Java: equals no es igualdad numérica.

equals: false  compareTo: 0
HashSet size: 2  TreeSet size: 1
stripTrailingZeros equals: true
new BigDecimal(0.1) = 0.1000000000000000055511151231257827021181583404541015625
BigDecimal.valueOf(0.1) = 0.1
10 / 3 (scale 2, HALF_EVEN) = 3.33

new BigDecimal("2.0").equals(new BigDecimal("2.00")) es false porque equals también compara la escala. Un HashSet con los dos montos tuvo tamaño 2; un TreeSet, que usa compareTo, tamaño 1. new BigDecimal(0.1) copia el error del float; BigDecimal.valueOf(0.1) pasa por la cadena más corta y da 0.1. Dividir sin escala lanza excepción: new BigDecimal("10").divide(new BigDecimal("3")) imprimió java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result., y setScale(2) sin modo de redondeo sobre 1.005 lanzó Rounding necessary.

decimal de C#: el más amable del grupo, con límites duros.

0.1 + 0.2 == 0.3 (double): False
0.1m + 0.2m == 0.3m: True
1m / 3m * 3m = 0.9999999999999999999999999999
2.0m == 2.00m: True, ToString: 2.0 vs 2.00, Equals: True
decimal.MaxValue = 79228162514264337593543950335
OverflowException: Value was either too large or too small for a Decimal.

decimal compara por valor pero conserva la escala al imprimir, y siempre lanza excepción al desbordarse, incluso fuera de un bloque checked (un long dio la vuelta a -9223372036854775808 sin checked).

bcmath de PHP: texto que entra, texto que sale, y la escala por defecto es 0.

bcmul('19.99','3') = 59   <- default scale 0
bcmul('19.99','3',2) = 59.97
bcdiv('2','3',2) = 0.66  <- truncates
bcadd('1e3','1') = ValueError: bcadd(): Argument #1 ($num1) is not well-formed
BcMath\Number('19.99') * 3 = 59.97

Olvidar el argumento de escala borra los centavos en silencio: bcmul('19.99', '3') devolvió 59. bcdiv trunca en vez de redondear, y la notación exponencial se rechaza. Ojo también con montos escritos con coma decimal ("19,99"): no son números para bcmath, normalízalos antes. PHP 8.4 añadió la clase BcMath\Number, que conserva la escala y admite operadores; en 8.5.6 devolvió 59.97.

Decimal de Swift: el literal pasa primero por Double.

Decimal(0.1) = 0.1
Decimal(19.99) = 19.98999999999999488
Decimal(string:"19.99")! * 3 = 59.97

Decimal(0.1) imprimió 0.1, lo que hace fácil no ver la trampa, pero Decimal(19.99) imprimió 19.98999999999999488 y el Decimal(1.005) de la clase 3 imprimió 1.0049999999999997952. Usa Decimal(string:).

Repartir un gasto o un descuento sin perder un centavo

100.00 entre tres no da tres montos iguales en centavos. Redondear cada parte por separado pierde o inventa centavos; el método del mayor resto lo resuelve:

# alloc.py
import random

def allocate(total, weights):
    """Split integer `total` (minor units) in proportion to `weights`.
    Largest remainder method: the parts always add up to `total`."""
    wsum = sum(weights)
    parts = [total * w // wsum for w in weights]          # floor of each share
    left = total - sum(parts)                             # units still to hand out
    by_rem = sorted(range(len(weights)), key=lambda i: (-(total * weights[i] % wsum), i))
    for i in by_rem[:left]:
        parts[i] += 1
    return parts

def naive(total, weights):
    """Round each share half-up on its own (the usual first attempt)."""
    wsum = sum(weights)
    return [(2 * total * w + wsum) // (2 * wsum) for w in weights]

for total, w, label in [(10000, [1, 1, 1], "$100.00 in 3"),
                        (100000, [1, 1, 1], "100,000 won in 3"),
                        (1000, [480, 980, 1980], "1,000 yen discount over 480/980/1980"),
                        (500, [1, 1, 1, 1, 1, 1], "5.00 EUR over 6 lines"),
                        (7, [1, 1, 1], "7 cents in 3")]:
    n = naive(total, w)
    print(f"{label}: naive {n} sum {sum(n)} | allocate {allocate(total, w)} sum {sum(allocate(total, w))}")

rng = random.Random(42)
T, bad, worst = 100_000, 0, 0
for _ in range(T):
    w = [rng.randrange(1, 10_000) for _ in range(rng.randrange(2, 8))]
    total = rng.randrange(100, 1_000_000)
    d = sum(naive(total, w)) - total
    if d:
        bad += 1; worst = max(worst, abs(d))
    assert sum(allocate(total, w)) == total
print(f"random splits: {T}, naive total wrong in {bad} ({bad / T:.1%}), worst {worst} units; allocate exact in all")
$100.00 in 3: naive [3333, 3333, 3333] sum 9999 | allocate [3334, 3333, 3333] sum 10000
100,000 won in 3: naive [33333, 33333, 33333] sum 99999 | allocate [33334, 33333, 33333] sum 100000
1,000 yen discount over 480/980/1980: naive [140, 285, 576] sum 1001 | allocate [139, 285, 576] sum 1000
5.00 EUR over 6 lines: naive [83, 83, 83, 83, 83, 83] sum 498 | allocate [84, 84, 83, 83, 83, 83] sum 500
7 cents in 3: naive [2, 2, 2] sum 6 | allocate [3, 2, 2] sum 7
random splits: 100000, naive total wrong in 31958 (32.0%), worst 3 units; allocate exact in all
Flujo: total 10000 centavos en proporción 1, 1, 1. Redondear cada parte hacia abajo da 3333, 3333, 3333, que suman 9999. Sobra un centavo. Se da al mayor resto, con empates por orden: 3334, 3333, 3333, suma 10000. Redondear cada parte por separado da 3333 tres veces y pierde un centavo.
Reparto por mayor resto de 100.00 entre tres personas, en centavos. Redondea hacia abajo cada parte, cuenta lo que sobra y da los centavos sobrantes a los mayores restos. Las partes siempre suman el total.

El redondeo ingenuo falla en las dos direcciones: un descuento de 5.00 EUR repartido en seis líneas sumó 4.98, y el descuento de 1,000 sumó 1,001, una unidad más de lo prometido. En 100,000 repartos aleatorios (semilla 42) se equivocó el 32.0% de las veces. El reparto por mayor resto es exacto siempre y determinista: los empates van a la línea anterior, así que la misma entrada da siempre la misma salida, lo que importa cuando un reembolso parcial revierte una sola línea. Si repartes las ganancias de un proyecto entre socios al 50/30/20, allocate(100001, [50, 30, 20]) dio [50001, 30000, 20000]: el centavo sobrante tiene dueño fijo y documentado.

Conversión de moneda: una tasa, un redondeo

Guarda las tasas de cambio como texto decimal, convierte con un tipo decimal y redondea una vez a la unidad mínima de la moneda de destino. Las tasas de abajo son inventadas.

# fx_es.py
from decimal import Decimal as D, ROUND_HALF_UP

def q(x, unit):
    return x.quantize(D(unit), ROUND_HALF_UP)

EUR_MXN = D("20.4137")      # tasas inventadas, guardadas como texto decimal
EUR_CLP = D("1043.86")
print("1234.56 EUR ->", D("1234.56") * EUR_MXN, "->", q(D("1234.56") * EUR_MXN, "0.01"), "MXN")
print("1234.56 EUR ->", D("1234.56") * EUR_CLP, "->", q(D("1234.56") * EUR_CLP, "1"), "CLP")
print("float 1234.56 * 20.4137 =", 1234.56 * 20.4137)

once  = q(D("39.99") * EUR_MXN * D("1.16"), "0.01")               # convertir + IVA 16%, un redondeo
twice = q(q(D("39.99") * EUR_MXN, "0.01") * D("1.16"), "0.01")   # redondear al convertir y otra vez
print("39.99 EUR + IVA 16% en MXN: un redondeo", once, "| dos redondeos", twice)

items = [D("0.99")] * 100
print("100 x 0.99 EUR en CLP: línea por línea", sum(q(p * EUR_CLP, "1") for p in items),
      "| el total", q(sum(items) * EUR_CLP, "1"))
1234.56 EUR -> 25201.937472 -> 25201.94 MXN
1234.56 EUR -> 1288707.8016 -> 1288708 CLP
float 1234.56 * 20.4137 = 25201.937471999998
39.99 EUR + IVA 16% en MXN: un redondeo 946.96 | dos redondeos 946.95
100 x 0.99 EUR en CLP: línea por línea 103300 | el total 103342

Fíjate en la unidad de redondeo: MXN a centavos ("0.01"), CLP a pesos enteros ("1"). Redondear dos veces movió un centavo. Convertir cien líneas de 0.99 EUR una por una dio 103,300 CLP en vez de 103,342, porque cada línea de 1033.4214 se redondeó a 1033. Decide si conviertes por línea o por pedido, y guarda la tasa y la regla de redondeo junto con la transacción para poder reproducir el número después, que es justo lo que te pedirá tu contador cuando cobras en euros y declaras en pesos.

Medido: lo que cuesta un decimal

La objeción habitual a los tipos decimales es la velocidad. Medimos el mismo trabajo en tres lenguajes: 1,000,000 de montos aleatorios (semilla 42), sumar 10% de impuesto con redondeo medio hacia arriba al centavo y totalizar. Mediana de 5 corridas en Python y de 7 en Java y .NET, Mac con Apple Silicon (M1 Pro).

# bench.py (parte de Python)
import random, statistics, time
from decimal import Decimal as D, ROUND_HALF_UP
N, REPS = 1_000_000, 5
rng = random.Random(42)
cents = [rng.randrange(1, 100_000) for _ in range(N)]     # 0.01 .. 999.99
floats = [c / 100 for c in cents]
decs = [D(c).scaleb(-2) for c in cents]
CENT, RATE = D("0.01"), D("1.10")

def with_int():   return sum((c * 110 + 50) // 100 for c in cents)
def with_float(): return sum(round(x * 1.10, 2) for x in floats)
def with_dec():   return sum((d * RATE).quantize(CENT, ROUND_HALF_UP) for d in decs)
Lenguaje Enteros en unidad mínima Float binario Tipo decimal
Python 3.9 64.3 ms 231.7 ms 173.7 ms (Decimal)
Python 3.12 54.7 ms 240.7 ms 160.3 ms (Decimal)
Java 26 1.4 ms (long) 1.6 ms (double) 22.5 ms (BigDecimal)
.NET 10 0.9 ms (long) 1.0 ms (double) 19.3 ms (decimal)
Gráfico de barras, veces más lento que los enteros del mismo lenguaje: Python float 3.6, Python Decimal 2.7, Java double 1.1, Java BigDecimal 16.1, .NET double 1.1, .NET decimal 21.4.
Costo relativo a enteros en unidades mínimas: 1,000,000 de montos, sumar 10% de impuesto con redondeo medio hacia arriba al centavo y totalizar (mediana de 5 corridas en Python 3.9 y de 7 en Java 26 y .NET 10; Mac con Apple Silicon M1 Pro). 1.0× es la versión con enteros del mismo lenguaje.

En Python, Decimal (implementado en C) fue más rápido que float con round(), y los enteros fueron los más rápidos. En Java y .NET los tipos decimales costaron 16× y 21× la versión con enteros, y aun así un millón de líneas con impuesto tardaron unos 20 ms. Para una petición web eso es ruido. Importa en procesos por lotes de cientos de millones de filas, otra razón para guardar enteros y usar decimales solo en los pasos que los necesitan.

Las versiones con float no solo fueron más lentas en Python: dieron mal. El total con float quedó 124.95 por debajo del exacto en Python (12,495 líneas un centavo abajo, ver clase 3), 6.83 en Java y 7.31 en .NET.

Cómo elegir la representación

Diagrama de decisión. Inicio: un monto que alguien paga o cobra. Si es solo una estimación o estadística, float sirve. Si no, y todo valor cabe en la unidad mínima de la moneda, guárdalo como entero: centavos para USD, EUR y MXN; yenes, wones o pesos enteros para JPY, KRW y CLP. Si necesitas tasas, precios unitarios con más dígitos o conversión de moneda, calcula con un tipo decimal (Decimal de Python, BigDecimal de Java, decimal de C#, bcmath de PHP, Decimal de Swift creado desde texto) y redondea una sola vez a la unidad mínima entera.
Cómo elegir la representación del dinero. Por defecto, enteros en unidades mínimas; un tipo decimal cuando tasas o precios necesitan más dígitos que la moneda; float binario solo donde nadie recibe una factura.
Necesitas Usa Cuidado con
Guardar, sumar, comparar montos Enteros en unidad mínima (columna BIGINT) Tabla de decimales por moneda; Number de JS sobre 2^53
Tasas de IVA, precios con más decimales Tipo decimal creado desde texto Decimal(float), escala, regla de redondeo por defecto
Repartos, descuentos, reembolsos Mayor resto sobre enteros Orden de desempate determinista
Conversión de moneda Tasa como texto decimal, un redondeo Guardar tasa y regla con la transacción
Gráficas, estimaciones, estadísticas float sirve Nunca devolver el resultado a la facturación

Errores comunes → qué pasa en realidad → solución

Error Lo que pasó en nuestras ejecuciones Solución
int(precio * 100) int(19.99 * 100) → 1998 Parsear el texto: to_minor("19.99", "USD")
Decimal(0.1), new BigDecimal(0.1), Decimal(19.99) en Swift 0.1000000000000000055511151231257827021181583404541015625, 19.98999999999999488 Construir desde texto; activar FloatOperation en Python
BigDecimal como clave de mapa HashSet con 2.0 y 2.00 tuvo tamaño 2 compareTo, o setScale(2) antes de guardar
bcmul sin escala bcmul('19.99','3') → 59 Pasar siempre la escala, o usar BcMath\Number
Redondear cada parte por separado 100.00 / 3 → 99.99 en total; 32.0% de repartos aleatorios mal Reparto por mayor resto
Convertir por línea sin querer 100 × 0.99 EUR → 103,300 vs 103,342 CLP Elegir por línea o por pedido a propósito y registrarlo
Decimales sacados de un formateador COP: 2 en Java y jsc, 0 en .NET y PHP Tabla propia por código ISO

Límites honestos / notas de versión

  • BcMath\Number llegó en PHP 8.4; solo ejecutamos 8.5.6. La tabla de decimales refleja ICU 78.3 en PHP, el ICU incluido con .NET 10 y los datos de monedas de Java 26; otras versiones pueden diferir.
  • Los tiempos son de una máquina, un trabajo y N pequeño. Java se ejecutó desde el código fuente (java Bench.java) y .NET con dotnet run -c Release; el calentamiento del JIT se absorbió con la mediana de varias corridas. Los montos de Java y .NET salieron de su propio Random(42), así que sus totales difieren de los de Python.
  • El 1.0 exacto de SQLite al sumar diez filas de 0.10 solo se observó en 3.51.0.
  • Las tasas de cambio y de IVA de los ejemplos son inventadas o ilustrativas. Nada de esto es asesoría contable, fiscal ni legal: tu contador decide las reglas de redondeo.

Ejercicios

1. Un producto cuesta 0.07 USD. Alguien calcula centavos con int(0.07 * 100). Python imprimió 0.07 * 100 = 7.000000000000001; ¿es seguro int() en este caso? Nombra una entrada de esta clase donde el mismo código falla.

2. Reparte un gasto compartido de 10.00 EUR entre siete personas en partes iguales con allocate(1000, [1] * 7). ¿Cuánto recibe cada una y quiénes se llevan los centavos extra?

Respuestas

1. Aquí funciona de casualidad: 7.000000000000001 truncado es 7. Falla con 19.99: int(19.99 * 100) dio 1998 porque el producto quedó justo por debajo de 1999. Que el código funcione con un precio y falle con otro es la razón para parsear texto.

2. 1000 // 7 = 142 centavos cada una, 994 en total, sobran 6. Todos los restos son iguales, así que el orden de desempate da los 6 centavos a las primeras seis personas: seis pagan 1.43 EUR y la séptima 1.42 EUR, total 10.00 (la ejecución dio [143, 143, 143, 143, 143, 143, 142]).

Sigue

Preguntas frecuentes

¿Guardo el dinero en centavos enteros o en un tipo decimal?

Guarda y suma los montos como enteros en la unidad mínima de la moneda (centavos para EUR, USD y MXN; pesos enteros para CLP), y usa un tipo decimal como Decimal de Python, BigDecimal de Java o decimal de C# solo en los pasos que necesitan más dígitos: tasas de IVA, precios unitarios con más decimales y conversión de moneda. Redondea una sola vez a la unidad mínima. Nunca uses float binario: int(19.99 * 100) dio 1998 en Python.

¿Por qué BigDecimal dice que 2.0 y 2.00 no son iguales?

Porque BigDecimal.equals compara el valor y la escala, así que new BigDecimal("2.0").equals(new BigDecimal("2.00")) imprimió false mientras compareTo imprimió 0. Un HashSet guardó los dos (tamaño 2) y un TreeSet uno solo. Compara dinero con compareTo, o normaliza la escala con setScale antes de usar montos como claves.

¿Cómo reparto un gasto sin perder un centavo?

Usa el método del mayor resto sobre enteros en unidades mínimas: redondea cada parte hacia abajo, cuenta cuántas unidades sobran y da una unidad extra a las partes con mayor resto. 100.00 entre tres queda 33.34, 33.33 y 33.33. Redondear cada parte por separado dio un total equivocado en el 32.0% de 100,000 repartos aleatorios en nuestra prueba.

  • #números
  • #intermedio
  • #dinero
  • #decimal
  • #bigdecimal
  • #facturas
  • #python
  • #java
  • #csharp
  • #php

t.laboratory

A technical blog that records real problems from the apps, servers and services we build and run — and the code that fixed them.

Acerca de · Apps

↑