Error de truncamiento

01 · Punto de partida

Cortar no es redondear

En el Tema 40 viste el redondeo del hardware: el vecino más cercano, error ≤ ½ ulp y sin sesgo. Truncar es lo contrario: cortar los decimales que sobran y quedarse con lo que entra, siempre hacia cero. Lo hacés cada vez que convertís con int(), que armás un índice con int(u * n) o que mostrás un precio con 2 decimales “cortados”.

El corte parece inofensivo, pero tiene dos pecados: pierde hasta el doble que redondear (1 unidad en vez de ½) y sesga: con positivos siempre resta, con negativos siempre suma. En una cuenta no pasa nada; en un millón de cuentas o en un histograma, el sesgo se ve.

• ¿Qué diferencia hay entre truncar, redondear y pisar (floor)?
• ¿Por qué int(-2,7) da −2 y no −3?
• ¿Cuánto se pierde al truncar a k decimales?
• ¿Dónde muerde el sesgo en simulación: índices, bins, plata?

02 · Definición

Tres cortes, tres destinos

03 · Anatomía

Dónde nace el sesgo

El redondeo del Tema 40 a veces suma y a veces resta: en promedio se compensa. El truncamiento con positivos siempre resta: cada corte deja una “basura” entre 0 y 10⁻ᵏ que nunca se recupera. Tres lugares donde aparece:

Truncamiento de visualización

Mostrar con int(x*100)/100 o cortar el string a 2 decimales: el ticket dice 2,67 aunque el valor real es 2,679. Para mostrar se usa round/formato, no corte.

Truncamiento de conversión

int(u * n) con u en [0,1): si u puede valer 1,0 por redondeo, el índice se sale de rango. Y con negativos, int no es floor: los bins se corren un lugar (Tema 35).

Truncamiento de modelo (aviso)

En métodos numéricos también se llama “truncamiento” a cortar una serie infinita (Taylor, Euler): otro corte con otro análisis. Acá nos ocupamos del corte de decimales; el de series reaparece en el Tema 43 como inestabilidad.

04 · Ejemplos

Tres cortes que duelen

1. 1
   El centavo fantasma.

   Truncar 2,679 a 2 decimales da 2,67 (pierde 0,009); redondear da 2,68 (pierde 0,001). En 100 000 tickets, el corte regala ~450 $ del mismo bolsillo.

2. 2
   El índice que se escapa.

   int(0,9999999 * 10) = 9 está bien, pero si el redondeo deja u = 1,0, int(1,0*10) = 10 explota la lista. El min(..., n-1) lo salva (Tema 22).

3. 3
   El bin corrido.

   Con int(x) sobre negativos, el intervalo [−3,−2) cae en −2 en vez de −3: el histograma cojea justo donde cruza el cero. Con floor cada bin mide 1 parejo.

05 · Demostración en Python

Cortar a mano y medir la basura

Dos funciones de 2 líneas separan todo: truncar corta, redondear elige al cercano. Medí la basura de cada una sobre el mismo valor.

import math

def truncar(x, k=2):
    f = 10 ** k
    return math.trunc(x * f) / f

def redondear(x, k=2):
    return round(x, k)

for v in [2.675, -2.675, 0.9999]:
    print(v, truncar(v), redondear(v))

Verás 2,67 vs 2,68, −2,67 vs −2,67… y el 0,99 vs 1,0: el corte pierde hasta 0,01 entero.

El sesgo en cámara lenta

import math
import random

random.seed(41)
vals = [random.random() * 10 for _ in range(20000)]
basura_trunc = sum(v - math.trunc(v * 100) / 100 for v in vals)
basura_round = sum(v - round(v, 2) for v in vals)
print("trunc suma:", round(basura_trunc, 2))
print("round suma:", round(basura_round, 4))

06 · Exploración

Laboratorio: truncar frente a redondear

Elegí un valor y cuántos decimales conservar (k). El punto verde es el valor real, el naranja el truncado y el celeste el redondeado, sobre el intervalo entre los dos múltiplos de 10⁻ᵏ que lo encierran. La barra naranja es siempre más larga que la celeste… o igual en el peor empate.

La recta es el intervalo de largo 10⁻ᵏ entre los dos candidatos. El truncado cae siempre en el borde hacia cero; el redondeado, en el más cercano al valor real.

Preguntas para explorar

1. Con π y k = 2: ¿cuánto pierde truncar (3,14) frente a redondear (3,14)? ¿Y con k = 0?
2. Con 2,675 y k = 2: ¿por qué el redondeado da 2,67 y no 2,68? (Pista: Tema 40.)
3. Con −2,675: ¿dónde cae el truncado respecto del redondeado? ¿Qué pasaría con floor?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: los tres destinos de −2,7

Mostrá en una línea que int, // y round no son sinónimos con negativos.

import math

x = -2.7
print(int(x), math.floor(x), round(x))
print(x // 1, math.trunc(x))

Ejercicio 2: el centavo que suma

Compará truncar frente a redondear 20 000 importes a 2 decimales: ¿cuánto regala cada uno en total?

import math
import random

random.seed(41)
vals = [random.random() * 100 for _ in range(20000)]
t = sum(v - math.trunc(v * 100) / 100 for v in vals)
r = sum(v - round(v, 2) for v in vals)
print("trunc regala:", round(t, 2))
print("round regala:", round(r, 4))

Ejercicio 3: bins sin corrimiento

Escribí bin_int (con int) y bin_floor (con floor) y probalas con valores a ambos lados del cero.

import math

def bin_int(x, w=1.0):
    return int(x / w)

def bin_floor(x, w=1.0):
    return math.floor(x / w)


for v in [-2.7, -2.0, -0.2, 0.2, 2.7]:
    print(v, bin_int(v), bin_floor(v))

09 · Síntesis

Ideas para recordar

En el próximo tema veremos qué pasa cuando esos cortes y redondeos se suman miles de veces: la acumulación de errores numéricos.