Por: Gino Marín

Publicado el: 8 de agosto de 2026

Colaboración Académica para la Universidad CENFOTEC

Agarrá la calculadora del teléfono y sumá 0,1 más 0,2. Te da 0,3, como corresponde. Ahora pedile lo mismo a la consola de casi cualquier lenguaje de programación, de esas que usan quienes programan todos los días, y mirá lo que aparece: 0,30000000000000004. Un chorro de decimales y, al fondo del todo, un 4 que no tiene por qué estar ahí.

La primera reacción es pensar que la máquina se equivocó. No lo hizo. Ese 4 no es un defecto ni un bug. Es la huella de cómo una computadora guarda los números por dentro, y entender esa huella es el primer paso para entender casi todo lo demás, desde por qué una simulación del clima acumula error hasta por qué un modelo de inteligencia artificial se puede comprimir cuatro veces sin que casi se note.

Empecemos por el problema de fondo. Una computadora no tiene infinitos casilleros para anotar cada número que se le cruza. Tiene una cantidad fija de espacio para cada uno, y con ese espacio limitado tiene que representar tanto la distancia entre dos ciudades como el tamaño de un átomo. Para lograrlo usa un formato que se llama punto flotante, en inglés «floating point», que es una forma ingeniosa de escribir números muy grandes y muy chicos gastando pocos bits.

La idea es la misma que la notación científica que viste en la escuela. En vez de escribir 300.000.000, escribís tres por diez a la ocho. Guardás dos cosas nada más: los dígitos que importan, el tres, y dónde va la coma, el ocho. Con esas dos piezas cubrís un rango enorme de tamaños sin tener que anotar todos los ceros. El punto flotante hace exactamente eso, pero en binario y de forma automática.

Una regla con las marcas desparejas

Acá viene la imagen que conviene tener en la cabeza. Pensá en una regla, pero no en una regla común. Pensá en una regla rara, en la que las marcas cerca del cero están apretadas, bien juntas, y a medida que te alejás del cero las marcas se van separando cada vez más. Cerca del cero podés medir con muchísimo detalle. Lejos, solo podés medir a lo bruto, saltando de una marca gorda a la siguiente.

El punto flotante es esa regla despareja. No reparte su precisión de manera uniforme a lo largo de toda la recta. La concentra donde los números son chicos y la va soltando a medida que crecen. Es un intercambio deliberado: a cambio de poder representar números gigantescos con pocos bits, aceptás que la resolución no sea la misma en todos lados.

La mayor parte del tiempo eso no molesta para nada. Cuando trabajás con números de tamaños parecidos, las marcas están lo bastante cerca como para que el resultado sea exacto o casi. El problema aparece en los bordes, y en un lugar más incómodo todavía, que ya vamos a ver.

Cada número guardado en este formato tiene tres partes. Una dice el signo, si el número va para el lado positivo o el negativo. Otra guarda los dígitos que importan, lo que en inglés se llama la «mantisa». Y la tercera dice qué tan grande es el número, o sea dónde cae la coma, lo que se llama el «exponent». Con esas tres piezas, y una cantidad fija de espacio para cada una, la máquina arma cualquier número que necesite. La cantidad de espacio que le toca a la mantisa es la que decide cuántos dígitos de detalle podés tener. Y ese espacio no es infinito.

Lejos del cero, dos números distintos se vuelven el mismo

Un ejemplo de lo que pasa en los extremos. Con la cantidad de bits que usa el formato más común, hay un punto en el que dos números enteros consecutivos, digamos uno y el siguiente, ya no caben los dos en la regla. Las marcas están tan separadas que entre uno y otro no hay ninguna. Entonces la máquina los guarda como si fueran el mismo número. Sumarle uno a esa cantidad, sencillamente, no cambia nada.

Suena a curiosidad de laboratorio, pero tiene consecuencias reales. Si estás llevando la cuenta de algo muy grande de a poquito, cada suma minúscula se pierde, porque no alcanza para llegar a la próxima marca. La cuenta se congela sin que nadie la haya tocado. Es la misma regla despareja mostrando su lado incómodo: donde los números son grandes, los detalles chicos desaparecen.

El problema de fondo: 0,1 no cae en ninguna marca

Y ahora sí, volvamos a 0,1 más 0,2, porque el asunto no es solo de números gigantes. El corazón del problema es más sutil y está justo en el medio de la regla.

Resulta que algunos números que para nosotros son redondísimos no caen exactos sobre ninguna marca de la regla binaria. El 0,1 es uno de ellos. En el sistema de base diez que usamos las personas, 0,1 es un décimo, limpio y cerrado. Pero la computadora no piensa en base diez, piensa en base dos, y en base dos el número 0,1 es como el número un tercio en base diez: un decimal que no termina nunca. Escribís 0,333 y seguís, y seguís, y nunca llegás al final.

La máquina no puede guardar un número infinito, así que lo corta donde se le acaba el espacio. Ese corte deja una miga, una diferencia minúscula entre el 0,1 que vos querías y el 0,1 que la máquina realmente guardó. Lo mismo pasa con 0,2. Cuando sumás dos números que ya venían con su propia miga, las migas se juntan, y el resultado se aleja apenas del 0,3 perfecto. Ese alejamiento es el 4 del final. No es un error de cálculo. Es la suma honesta de dos aproximaciones.

Por qué esto te importa aunque no programes

Podrías decir, con razón, que una miga tan chica no le arruina la vida a nadie. Y es cierto casi siempre. Pagás la cuenta del supermercado, sumás dos precios, y la miga es tan pequeña que ni la ves. El problema no es una suma. El problema es un millón de sumas.

Cuando un programa acumula millones o miles de millones de operaciones, esas migas dejan de ser inofensivas. Se apilan. En una simulación del clima, en un cálculo de física, en el motor de un banco que procesa millones de transacciones, el error acumulado puede volverse visible y hasta peligroso si nadie lo tiene en cuenta. Por eso quienes programan cosas serias aprenden temprano una regla incómoda: nunca preguntes si dos números con coma son exactamente iguales, porque casi nunca lo son. Preguntá si están lo bastante cerca.

El caso más citado de esto es trágico. En 1991, durante la Guerra del Golfo, una batería de misiles Patriot no logró interceptar un proyectil enemigo que impactó contra un cuartel y mató a veintiocho personas. La investigación posterior encontró la causa en una miga de punto flotante. El reloj interno del sistema acumulaba un error minúsculo en cada fracción de segundo, y tras unas cien horas encendido sin reiniciarse, ese error se había vuelto lo bastante grande como para calcular mal la posición del blanco. Una miga sola no le hace nada a nadie. Multiplicada por el tiempo suficiente, corrió el cálculo lo justo para fallar.

Y hay un terreno donde todo esto se vuelve central: la inteligencia artificial. Un modelo moderno hace una cantidad astronómica de cuentas con números de punto flotante, miles de millones de ellos, una y otra vez. La forma en que esos números se guardan y se redondean no es un detalle técnico menor. Es la base sobre la que se apoya todo lo demás, incluida la posibilidad de achicar el modelo para que entre en un teléfono. Pero esa es la historia de las próximas dos notas.

Nada de esto es un secreto ni un descubrimiento reciente. William Kahan, profesor emérito de la Universidad de California en Berkeley y arquitecto principal del estándar que casi todas las computadoras del mundo usan para representar estos números, ganó el Premio Turing, el equivalente al Nobel en computación, justamente por poner orden en este terreno. A veces lo llaman el padre del punto flotante. El comportamiento de las migas está estudiado hasta el último rincón. David Goldberg, en un trabajo que sigue siendo lectura obligatoria décadas después, tituló su guía sin vueltas: lo que todo científico de la computación debería saber sobre la aritmética de punto flotante.

La conclusión práctica es sencilla, y es la que hay que retener antes de seguir con la serie. Reducir la cantidad de bits con la que guardás un número no es cortarlo a lo bruto y ya. Si querés que siga significando algo parecido, necesitás un mapa que decida a qué marca va a parar cada valor. Ese mapa tiene nombre, se llama cuantización, y es de lo que hablan las próximas dos entregas.

¿La computadora se equivoca cuando insiste en que 0,1 más 0,2 no es 0,3? La respuesta corta: no. La respuesta larga: hace lo mejor que puede con los casilleros que tiene, en una regla que eligió a propósito para poder medir tanto lo enorme como lo minúsculo. El error, cuando aparece, casi siempre lo ponemos nosotros, al olvidar que esa regla estaba ahí todo el tiempo.

—

Referencias

– David Goldberg. What Every Computer Scientist Should Know About Floating-Point Arithmetic. ACM Computing Surveys, 1991. https://dl.acm.org/doi/10.1145/103162.103163

– IEEE. IEEE Standard for Floating-Point Arithmetic (IEEE 754-2019). https://standards.ieee.org/ieee/754/6210/

– Charles Severance. An Interview with the Old Man of Floating-Point, entrevista a William Kahan. https://people.eecs.berkeley.edu/~wkahan/ieee754status/754story.html

– U.S. Government Accountability Office. Patriot Missile Defense: Software Problem Led to System Failure at Dhahran, Saudi Arabia. Informe GAO/IMTEC-92-26, 1992. https://www.gao.gov/products/imtec-92-26