Error al sumar floats, NaN y -0.0, medidos
Curso de números 6: sumar 10^7 doubles se desvió 396 ulps, sum() de Python 3.12 fue exacto, -ffast-math borró Kahan y volvió 0/0 en 1, y NaN rompió el orden.
Serie: curso de números y dinero 6/6 (avanzado). Esta última clase es para quien suma muchos números de punto flotante: totales de analítica, datos de sensores, puntajes, estadísticas, física de videojuegos o reportes mensuales que deben cuadrar con los del mes anterior. Al terminar sabrás qué tan rápido crece el error de una suma, qué algoritmo lo elimina y cuánto cuesta, qué hacen NaN y el cero negativo con el ordenamiento, max y JSON, y qué borra -ffast-math de tu código C sin avisar. Cierra con una lista de verificación de toda la serie.
En la clase 1 vimos que 0.1 + 0.2 da 0.30000000000000004. Un dígito mal en la posición 17 parece inofensivo. Esta clase trata de qué pasa cuando haces eso diez millones de veces, y de dos valores especiales, NaN y -0.0, que se cuelan en las revisiones de código porque se comparan de formas sorprendentes. Si facturas en pesos chilenos o colombianos guardas enteros y el monto está a salvo; el problema aparece al acumular lo que queda en decimales: comisiones porcentuales, conversiones de USD a MXN, promedios y varianzas. Todo se ejecutó en una Mac con Apple Silicon (M1 Pro): Python 3.9.6 y 3.12.14, clang 21 de Apple, el shell jsc de JavaScriptCore de macOS, PHP 8.5.6, Java 26, .NET 10.0.14, Swift 6.4.2 y SQLite 3.51.0. Los datos aleatorios usan random.Random(42), así que puedes reproducir cada número.
Sumar 0.1 diez millones de veces
La prueba más simple: sumar 0.1 a un acumulador 10,000,000 de veces. La respuesta exacta es 1,000,000.
| Runtime | Resultado |
|---|---|
Python 3.9.6, bucle y sum() |
999999.9998389754 |
Python 3.12.14 sum() |
1000000.0 |
Python math.fsum (ambas versiones) |
1000000.0 |
bucle for en jsc |
999999.9998389754 |
bucle en PHP 8.5.6 (var_export) |
999999.9998389754 |
bucle C# con double |
999999.9998389754 |
bucle C# con decimal y 0.1m |
1000000.0 |
SQLite 3.51.0 SELECT sum(0.1) sobre 10^7 filas |
1000000.0 |
El error es 0.00016, visible para cualquiera que revise el total de un reporte. Ojo con el cambio silencioso: sum() de Python 3.12 pasó a usar suma compensada (la variante de Neumaier), así que el mismo script imprimió otro total tras actualizar Python. sum() de SQLite también dio el resultado exacto aquí; las versiones recientes de SQLite usan la misma familia de suma compensada (Kahan-Babuska-Neumaier). El echo de PHP imprimió 999999.99983898, ocultando tres dígitos; var_export mostró el valor completo.
Otro clásico: math.fsum([1e100, 1.0, -1e100]) da 1.0, mientras que el bucle simple y sum() de Python 3.9 dan 0.0, porque el 1.0 desapareció al sumarse a 1e100. sum() de Python 3.12 devolvió 1.0.
Cómo crece el error con N
Cada + redondea su resultado al double más cercano, así que un bucle simple comete un error de redondeo por elemento. Los errores se cancelan en parte, de modo que el total crece más despacio que N, pero crece. Lo medimos en ulps (unidades en el último lugar: la distancia entre doubles vecinos a esa magnitud) frente a math.fsum, que devuelve la suma correctamente redondeada. Como verificación, la suma exacta con Fraction de los primeros 10^6 valores coincidió bit a bit con fsum.
def naive(xs):
s = 0.0
for x in xs: s += x
return s
def kahan(xs):
s = c = 0.0
for x in xs:
y = x - c; t = s + y; c = (t - s) - y; s = t
return s
def neumaier(xs):
s = c = 0.0
for x in xs:
t = s + x
if abs(s) >= abs(x): c += (s - t) + x
else: c += (x - t) + s
s = t
return s + c
Valores uniformes en [0, 1) (error en ulps frente a fsum):
| N | bucle simple | orden ascendente | por pares | Kahan | Neumaier |
|---|---|---|---|---|---|
| 10^3 | 1 | 2 | 0 | 0 | 0 |
| 10^4 | 0 | 5 | 0 | 0 | 0 |
| 10^5 | 54 | 50 | 0 | 0 | 0 |
| 10^6 | 33 | 102 | 0 | 0 | 0 |
| 10^7 | 396 | 64 | 1 | 0 | 0 |
Signos y magnitudes mezclados (uniform(-1, 1) * 10**randint(-8, 8)):
| N | bucle simple | orden ascendente | orden por valor absoluto | por pares | Kahan | Neumaier |
|---|---|---|---|---|---|---|
| 10^3 | 15 | 372 | 4 | 8 | 1 | 0 |
| 10^5 | 64 | 5,155 | 3 | 2 | 0 | 0 |
| 10^6 | 129 | 3,912 | 55 | 0 | 0 | 0 |
| 10^7 | 532 | 54,006 | 44 | 1 | 0 | 0 |
Dos lecciones. Primero, el error no crece de forma monótona con N (33 ulps en 10^6, 54 en 10^5): es una caminata aleatoria, y por eso un test que pasa con unos datos falla con otros. Segundo, el consejo popular "ordena de menor a mayor antes de sumar" ayudó con números positivos y empeoró todo cien veces con signos mezclados, porque los negativos grandes se suman primero y el acumulador se vuelve un número enorme que se traga a los pequeños. Ordenar por valor absoluto ayudó, pero dejó 44 ulps. Los algoritmos compensados ganan a ambos.
Lo que cuesta la exactitud
Con 10^6 valores, mediana de 5 corridas, Mac con Apple Silicon (M1 Pro):
| Método | Python 3.9.6 | Python 3.12.14 |
|---|---|---|
sum() integrado |
2.5 ms (sin compensar) | 2.5 ms (compensado) |
bucle for simple |
19.2 ms | 11.8 ms |
math.fsum |
16.6 ms | 7.3 ms |
bucle for de Kahan |
59.8 ms | 32.5 ms |
sum(sorted(xs)) |
169.0 ms | 153.4 ms |
sum() de valores Decimal |
39.2 ms | 41.7 ms |
En Python la respuesta es sencilla: en 3.12, sum() es el más rápido y además compensado; en versiones anteriores usa math.fsum, que es exacto y aun así más rápido que un bucle escrito a mano. Ordenar es lo más lento y no lo más preciso.
En C, con 10^7 doubles (mejor de 5, clang -O2): bucle simple 9.71 ms, Kahan 37.37 ms. Kahan cuesta unas cuatro veces más porque cada paso depende del anterior y la CPU no puede solapar sumas. Es un precio razonable para una contabilidad y demasiado alto para el bucle de un juego.
float32 frente a float64
Un float (32 bits) guarda unos 7 dígitos decimales significativos; un double (64 bits), unos 16. Los mismos 10^7 valores, sumados en C:
double naive sum=4998269.0432556057 abs err=-3.69e-07 9.71 ms
double kahan sum=4998269.0432559745 abs err=0 37.37 ms
float naive sum=4998096.5 abs err=-173 9.32 ms
float data, double acc sum=4998269.0432599643 abs err=3.99e-06 9.33 ms
float: add 1.0f twenty million times -> 16777216.0
Acumular en una variable float se desvió 173 de cinco millones. Por encima de 4,194,304 (2^22) la distancia entre floats vecinos es 0.5, así que cada sumando de [0, 1) se redondea a 0, 0.5 o 1 antes de contar. Guardar los datos como float pero acumular en double no costó tiempo extra y bajó el error a 4e-6, que es solo el redondeo de los valores guardados. La última línea es la más llamativa: un contador float se detiene en 2^24 = 16,777,216, porque 16,777,216 + 1 se redondea de vuelta a 16,777,216. Java imprimió 1.6777216E7 con el mismo bucle y Math.fround(16777217) en jsc devolvió 16777216.
Regla: float32 sirve para guardar arreglos grandes (pesos de ML, vértices) y para cálculos en GPU; acumula totales, promedios y varianzas en float64.
-ffast-math: más rápido, distinto y ciego a NaN
-ffast-math le dice a clang que puede tratar la aritmética de punto flotante como álgebra de números reales: reordenar sumas, suponer que no hay NaN ni infinitos e ignorar el signo del cero. Compilamos los mismos archivos de dos formas:
| Salida | -O2 |
-O2 -ffast-math |
|---|---|---|
| suma simple de doubles (10^7) | error -3.69e-07, 9.71 ms | error 3.45e-08, 1.75 ms |
| suma de Kahan | error 0, 37.37 ms | error 3.45e-08, 1.58 ms |
| suma simple de floats | error -173 | error 18 |
1.0f sumado 2×10^7 veces |
16777216.0 | 20000000.0 |
z/z con z = atof("0") |
nan |
1.000000 |
v != v con v = strtod("nan") |
1 | 0 |
Qué pasó: al permitir reordenar, clang vectorizó el bucle simple en varias sumas parciales, lo que lo hizo 5.5 veces más rápido y, por suerte, más preciso (se comporta como una suma por pares poco profunda). Pero también demostró que la corrección de Kahan (t - s) - y es algebraicamente cero y la borró: la función de Kahan devolvió exactamente el mismo valor que la simple. El bucle del contador float se reemplazó por un 20,000,000 calculado, la respuesta "correcta" que la aritmética IEEE estricta no puede dar. Y como el compilador supone que NaN no existe, el 0/0 en tiempo de ejecución se volvió 1.0 y la comprobación de NaN por autocomparación dio falso. Solo la llamada de biblioteca isnan() en nuestra función auxiliar noinline siguió funcionando, y clang mostró warning: use of NaN is undefined behavior due to the currently enabled floating-point options [-Wnan-infinity-disabled] donde usamos la macro NAN.
Así que nunca compiles suma compensada, aritmética de intervalos ni comprobaciones de NaN con -ffast-math. Si quieres la velocidad, usa varios acumuladores explícitos o suma por pares, que se vectorizan sin mentirle al compilador. Más sobre cómo el optimizador aprovecha supuestos: comportamiento indefinido en C y optimización.
NaN: comparación, ordenamiento, max y JSON
NaN ("not a number") sale de 0/0, inf - inf, 0 * inf, parseos fallidos y datos faltantes. Su propiedad clave: toda comparación con NaN es falsa, incluida NaN == NaN. Los algoritmos de ordenamiento y max suponen un orden coherente, así que fallan de formas que dependen de dónde está el NaN:
Python sorted([3, nan, 1, 2]) -> [3, nan, 1, 2] (¡sin cambios!)
Python sorted([nan, 3, 1, 2]) -> [nan, 1, 2, 3]
Python max([nan, 1, 2]) / max([1, 2, nan]) -> nan / 2
Python statistics.median([1, nan, 3, 2, 5]) -> 2
Swift [3, .nan, 1, 2].sorted() -> [3.0, nan, 1.0, 2.0]
jsc [3, NaN, 1, 10, 2].sort((a, b) => a - b) -> 3,NaN,1,2,10
jsc [3, NaN, 1, 10, 2].sort() -> 1,10,2,3,NaN (orden de texto)
PHP sort([3, NAN, 1, 2]) -> [NAN, 1, 2, 3]
PHP max(NAN, 1) / max(1, NAN) -> 1 / NAN
Java Arrays.sort(double[]) -> [-0.0, 0.0, 1.0, 2.0, 3.0, NaN]
C# Array.Sort(double[]) -> NaN, 0, -0, 1, 2, 3
C# Math.Max(NaN, 1) / LINQ Max([1, NaN, 2]) -> NaN / 2
Java y C# definen un orden total para ordenar (NaN al final en Java, al principio en C#), y por eso ordenan bien; los demás devuelven basura sin error. Hasta median devolvió un 2 que parece razonable. Lo peligroso no es el NaN que ves, sino la respuesta equivocada a su lado.
La pertenencia también es rara. En Python, nan in [nan] es True (encuentra el mismo objeto por identidad), pero float('nan') in [float('nan')] es False, y {float('nan'), float('nan')} tiene dos elementos. En jsc, [NaN].includes(NaN) es true pero [NaN].indexOf(NaN) es -1, e isNaN("abc") es true mientras que Number.isNaN("abc") es false.
JSON no tiene NaN. Cada lenguaje reacciona distinto:
| Llamada | Resultado |
|---|---|
Python json.dumps([nan, inf, -0.0]) |
[NaN, Infinity, -0.0] (JSON no válido) |
Python json.dumps(nan, allow_nan=False) |
ValueError: Out of range float values are not JSON compliant |
jsc JSON.stringify([NaN, Infinity, -0]) |
[null,null,0] |
jsc JSON.parse('[NaN]') |
SyntaxError: JSON Parse error: Unexpected identifier "NaN" |
PHP json_encode(NAN) |
false, Inf and NaN cannot be JSON encoded |
.NET JsonSerializer.Serialize(double.NaN) |
ArgumentException: .NET number values such as positive and negative infinity cannot be written as valid JSON. |
SQLite INSERT … VALUES (9e999 - 9e999) |
se guarda como NULL |
Así, un servicio en Python que emite NaN rompe el JSON.parse de un cliente JavaScript, el cliente JavaScript convierte NaN en null sin avisar, y SQLite lo vuelve NULL, que sum() y avg() luego ignoran. Decide en la frontera: rechaza NaN en la entrada y envía null a propósito cuando falte un valor. La clase 2 trató el problema relacionado de los IDs enteros grandes en JSON; mira también cómo las sentencias preparadas cambian los tipos numéricos en JSON con PHP (en inglés).
El cero negativo
IEEE 754 tiene dos ceros. -0.0 == 0.0 es verdadero en todos los lenguajes que probamos, pero el signo se escapa:
1 / -0.0es-infen C y-Infinityen jsc.- En Python
repr(-0.0)es-0.0;max(0.0, -0.0)devolvió0.0ymax(-0.0, 0.0)devolvió-0.0(en empate gana el primero). - Formatear un valor negativo diminuto imprime el signo menos: Python
f"{-0.004:.2f}", jsc(-0.004).toFixed(2), JavaString.format("%.2f", -0.004)y .NETToString("F2")imprimieron-0.00;Intl.NumberFormat("en-US", {maximumFractionDigits: 2})en jsc imprimió-0. PHPnumber_format(-0.004, 2)imprimió0.00. - En Java,
Double.valueOf(0.0).equals(-0.0)es false, así que unHashMap<Double, …>guarda las dos claves. JSON.stringify(-0)es0; PHPjson_encode(-0.0)es-0; SQLite guardó-0.0como0.0.
Una diferencia cambiaria de 0.004 que aparece como -0,00 € en una factura es la queja real más común. Redondea primero a la unidad mínima de la moneda (clase 4) y normaliza el cero antes de formatear.
Errores comunes → qué pasa realmente → cómo arreglarlo
| Error | Lo que vimos | Arreglo |
|---|---|---|
| Sumar millones de floats en un bucle | 396 ulps de error en 10^7 | math.fsum, Neumaier o sum() de Python 3.12+ |
| "Ordena primero y luego suma" | signos mezclados: 54,006 ulps | suma compensada |
| Acumulador float32 | 173 de error en cinco millones | acumular en float64 |
| Contador float | se queda en 16,777,216 | contador entero |
Kahan + -ffast-math |
corrección borrada | sin fast-math en ese archivo |
sorted() / max() con NaN |
lista sin ordenar, max según el orden | filtrar isnan antes |
json.dumps con NaN |
JSON inválido para otros parsers | allow_nan=False, enviar null |
| Mostrar un negativo diminuto redondeado | -0.00 |
redondear y normalizar el cero |
Comparar totales con == |
Python 3.9 y 3.12 dan totales distintos | centavos enteros o math.isclose |
Cuándo usar int, Decimal o float
- Dinero, impuestos, todo lo que deba cuadrar con un recibo: enteros en la unidad mínima (centavos de MXN o EUR; pesos enteros en CLP), o Decimal cuando hay tasas o fracciones de centavo (clase 4).
decimalde C# sumó 0.1 diez millones de veces y obtuvo exactamente 1000000.0. - Conteos e IDs: enteros de 64 bits; strings en JSON si pueden superar 2^53 (clase 2).
- Mediciones, estadística, ML, gráficos: float64. float32 solo para guardar o para GPU, acumulando en float64. Suma con
fsumo un método compensado cuando N es grande o comparas resultados entre corridas.
Lista de verificación de la serie
- Conoce tu tipo: un literal como
0.1ya está redondeado en binario (clase 1). Compara floats con tolerancia, nunca con==. - Conoce tus límites: 2^31, 2^63 y 2^53 para los números de JavaScript y JSON (clase 2).
- Elige el modo de redondeo a propósito (mitad al par o mitad hacia arriba) y redondea una vez, al final. Las reglas de IVA cambian por país: revisa las de tu país o consulta a tu contador (clase 3).
- Guarda el dinero como enteros de unidad mínima o Decimal, nunca como float (clase 4).
- No guardes números formateados; parsea la entrada con un locale explícito y un patrón estricto, sobre todo con la coma decimal (clase 5).
- Suma con un algoritmo compensado, deja NaN fuera en la frontera, normaliza -0.0 antes de mostrarlo y mantén
-ffast-mathlejos del código que debe ser exacto (esta clase). - Escribe tests para los valores frontera: 0.1, 2.5, -0.0, NaN, 2^53 + 1, entrada vacía. Mira tus primeros tests unitarios.
Límites honestos / notas de versión
sum()de Python usa suma compensada (Neumaier) para floats desde 3.12; ejecutamos 3.9.6 (simple) y 3.12.14 (compensada).- El resultado exacto de
sum(0.1)en SQLite se midió solo en 3.51.0; versiones viejas usaban una suma simple, así que revisa la tuya. - Los resultados de
-ffast-mathson de clang 21 de Apple en arm64. GCC y otras arquitecturas reordenan distinto; borrar la corrección de Kahan y plegar NaN es habitual, pero los números exactos no son portables. No se ejecutó en Linux. - El error en ulps depende de los datos. Nuestros dos conjuntos salen de
random.Random(42); otras distribuciones dan otros números, pero el orden de los métodos fue el mismo. - Los tiempos son de una sola máquina (M1 Pro, mejor o mediana de 5) sin más control de calentamiento.
Ejercicios
1. Un dashboard calcula la facturación del día sumando 2 millones de importes float con Python 3.9 y la compara con la cifra de ayer, calculada por un job en Python 3.12. Difieren en el décimo dígito. Di la causa y dos arreglos.
2. Sin ejecutarlo: ¿qué imprime Python con max([float("nan"), 5.0]) y con max([5.0, float("nan")]), y qué escribirías en su lugar?
Respuestas
1. sum() de Python 3.12 es compensado y el de 3.9 no, así que los últimos dígitos difieren (vimos 999999.9998389754 frente a 1000000.0 en la prueba de 0.1). Arreglos: usar math.fsum en los dos jobs; o, mejor para facturación, guardar centavos enteros y sumar enteros, que es exacto en cualquier versión.
2. nan y 5.0, en ese orden: max se queda con el primer elemento y solo lo reemplaza cuando x > actual es verdadero, cosa que nunca pasa con NaN en ningún lado. Usa max(x for x in xs if not math.isnan(x)) y decide de forma explícita qué significa un NaN en la entrada (normalmente: rechazarlo antes).
Sigue
- Anterior: Números y dinero 5/6: formatear y parsear números por locale
- Desde el inicio: 1/6: por qué 0.1 + 0.2 no da 0.3 · 2/6: desbordamiento de enteros y límites seguros · 3/6: modos de redondeo e IVA · 4/6: centavos enteros y Decimal
- Números en motores JavaScript: rendimiento, memoria y números en JS
- Tipos y printf en C: fundamentos de C: tipos, printf y compilación
- Agregados en SQL: SQL básico: SELECT, WHERE y ORDER BY
- Todas las series: ruta de aprendizaje de programación
Preguntas frecuentes
¿Ordenar los números antes de sumarlos arregla el error?
No siempre. Con diez millones de valores positivos en [0,1), ordenar de menor a mayor bajó el error de 396 a 64 ulps, pero con signos y magnitudes mezclados lo empeoró: 54,006 ulps frente a 532 del bucle simple. Kahan, Neumaier, math.fsum y sum() de Python 3.12 quedaron en 0 o 1 ulp en todos los casos que ejecutamos.
¿Qué hace sorted() de Python si hay un NaN?
Toda comparación con NaN es False, así que el algoritmo recibe respuestas incoherentes. sorted([3, nan, 1, 2]) devolvió [3, nan, 1, 2] sin cambios, max([nan, 1, 2]) devolvió nan pero max([1, 2, nan]) devolvió 2, y statistics.median([1, nan, 3, 2, 5]) devolvió 2. Swift y jsc fallaron igual. Filtra con math.isnan antes de ordenar.
¿Es seguro compilar con -ffast-math?
Solo si tu código no depende del redondeo exacto ni de NaN. Con clang -O2 -ffast-math, la suma de Kahan dio lo mismo que el bucle simple, 0.0/0.0 calculado en tiempo de ejecución imprimió 1.000000 en lugar de nan y v != v dio 0 para un NaN leído de la entrada. La suma simple fue 5.5 veces más rápida y, por suerte, más precisa.