Error de redondeo

01 · Punto de partida

Toda operación miente un poco

En el Tema 39 viste el formato: el double es una grilla finita de 53 bits donde 0,1 ni siquiera existe. Ahora viene el primo operativo: cada vez que sumás, restás, multiplicás, dividís o sacás raíz, el resultado matemático casi nunca cae justo sobre la grilla, y el hardware lo redondea al double más cercano. Un error chico, sí: como mucho medio paso de grilla. Pero tu simulación hace millones de esas operaciones seguidas (Temas 42–43).

La buena noticia: ese error tiene contrato escrito (IEEE 754): acotado, predecible y casi siempre de “redondeo correcto”. Entender el contrato es lo que separa al que depura del que reza.

• ¿Cuánto puede mentir una sola operación, en el peor caso?
• ¿Qué significa “redondeo al par” y cuándo lo notás?
• ¿Por qué 1/3 y 2,675 no son lo que parecen?
• ¿Cómo mido el error sin salir de Python?

02 · Definición

El contrato: medio ulp por operación

03 · Anatomía

Representación, operación y empate

“Redondeo” se usa para tres momentos distintos. Mezclarlos es la mitad de los bugs de punto flotante:

Redondeo de representación

Al escribir 0.1 o 2.675 ya redondeás: el literal se convierte al vecino más cercano. El error nace antes de operar. (Tema 39.)

Redondeo de operación

Cada + − * / sqrt calcula exacto por dentro (con bits extra) y redondea una sola vez al final. Error ≤ ½ ulp por operación, ni más ni menos.

Empate al par

El caso borde “justo al medio” se resuelve hacia la mantisa par: 2⁵³+1 → 2⁵³ y 2⁵³+3 → 2⁵³+4. Por eso los enteros grandes se vuelven salteados (laboratorio).

04 · Ejemplos

Tres redondeos que verás en tu carrera

1. 1
   1/3 no existe.

   El real 0,333… cae entre dos doubles: Python guarda 0,3333333333333333148. Error de 0,16 ulp, invisible hasta que lo restás de sí mismo escalado.

2. 2
   2,675 se imprime 2,67.

   El literal ya es 2,67499999999999982…: redondear a 2 decimales da 2,67 aunque en el pizarrón “debería” dar 2,68. No es bug del round: es el vecino.

3. 3
   2⁵³+1 == 2⁵³.

   Más allá de 9007199254740992 el paso es 2: los impares no existen y redondean al par más cercano. Contadores e IDs enteros gigantes no van en float.

05 · Demostración en Python

Medir el medio ulp

Python expone la grilla: math.ulp te da el paso local y Fraction te da el valor exacto para comparar. Tres líneas y ves el contrato en vivo.

import math
from fractions import Fraction

x = 1 / 3
exacto = Fraction(1, 3)
print(repr(x))
print("ulp en 1/3:", math.ulp(x))
print("error en ulps:", float(Fraction(x) - exacto) / math.ulp(x))

Verás el vecino …3148 y un error de una fracción de ulp: redondeo correcto, ni más ni menos.

El par que se come los impares

base = 2 ** 53
for n in [base - 1, base, base + 1, base + 2, base + 3]:
    print(n, "->", float(n) == float(n + 0.0), int(float(n)) - n)

06 · Exploración

Laboratorio: los enteros que desaparecen

Movete alrededor de 2⁵³ = 9007199254740992: debajo todos los enteros existen; encima el paso es 2 y los impares redondean al par más cercano. Cada barra es el error |fl(N) − N|: 0 = existe, 1 = redondeado al vecino.

La curva es el error de cada entero N: 0 donde el entero existe en la grilla, 1 donde colapsa al par vecino. Pasado 2⁵³ el patrón 0-1-1-0 se repite.

Preguntas para explorar

1. Con inicio −4 y 32 valores: ¿desde qué N el error deja de ser 0? ¿Qué tiene de especial ese N?
2. Subí el inicio a +40: ¿qué fracción de enteros es representable? ¿Qué pasa con N+1 == N?
3. Si un ID o un reloj de simulación vive en float pasado 2⁵³, ¿qué eventos se pisan?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: medir tu primer ulp

Mostrá que el paso en 1,0 es ε y que 1/3 vive a una fracción de ulp del real.

import math
from fractions import Fraction

print(math.ulp(1.0))
err = float(Fraction(1 / 3) - Fraction(1, 3))
print(repr(1 / 3), err / math.ulp(1 / 3))

Ejercicio 2: el impar que no existe

Verificá que 2⁵³+1 colapsa al par y que 2⁵³+3 salta al par siguiente.

base = 2 ** 53
print(int(float(base + 1)) - (base + 1))
print(int(float(base + 3)) - (base + 3))
print(float(base + 1) == float(base))

Ejercicio 3: redondear a mano

Escribí vecinos(x) que devuelva los dos doubles adyacentes y el error de x en ulps usando Fraction como verdad.

import math
from fractions import Fraction

def vecinos(x, num=1, den=10):
    exacto = Fraction(num, den)
    u = math.ulp(float(x))
    err_ulp = float(Fraction(float(x)) - exacto) / u
    abajo = math.nextafter(float(x), float("-inf"))
    arriba = math.nextafter(float(x), float("inf"))
    return abajo, float(x), arriba, err_ulp


print(vecinos(0.1))

09 · Síntesis

Ideas para recordar

En el próximo tema, el hermano sesgado del redondeo: el error de truncamiento, cuando cortamos decimales a propósito.