¿Qué es el estándar IEEE 754?

El estándar IEEE 754 es la norma internacional que define cómo los ordenadores representan y operan con números de punto flotante. Fue publicado en 1985 y revisado en 2008. Especifica dos formatos principales: precisión simple (32 bits, tipo float en C/Java) y precisión doble (64 bits, tipo double), así como las reglas de redondeo y el tratamiento de valores especiales como infinito o NaN (Not a Number).

¿Cuáles son las partes de un número en formato IEEE 754?

Un número IEEE 754 se divide en tres campos: el bit de signo (0 = positivo, 1 = negativo), el exponente con sesgo (8 bits en simple, 11 en doble) y la mantisa o fracción (23 bits en simple, 52 en doble). El valor final se calcula como: (-1)^signo × 2^(exponente - sesgo) × (1 + mantisa). El sesgo es 127 para precisión simple y 1023 para doble.

¿Por qué 0.1 + 0.2 no es exactamente 0.3 en los ordenadores?

Porque 0.1 y 0.2 no pueden representarse de forma exacta en binario, al igual que 1/3 no puede representarse exactamente en decimal. El estándar IEEE 754 almacena aproximaciones de estos valores, y la suma de dos aproximaciones acumula el error. El resultado real de 0.1 + 0.2 en punto flotante de 64 bits es 0.30000000000000004, no 0.3. Esto afecta a todos los lenguajes que usan IEEE 754 (Python, JavaScript, Java, C, etc.).

¿Cuándo usar precisión simple (32 bits) y cuándo doble (64 bits)?

La precisión simple ocupa 4 bytes y tiene una precisión de aproximadamente 7 dígitos decimales significativos; es suficiente para gráficos 3D, audio o aprendizaje automático donde se prioriza el rendimiento. La precisión doble ocupa 8 bytes y ofrece unos 15-16 dígitos significativos; es la opción estándar en cálculos científicos, financieros o de ingeniería donde la exactitud importa más que la velocidad.

¿Qué son NaN e Infinito en IEEE 754?

Son valores especiales definidos por el estándar. Infinito positivo o negativo se produce al dividir un número por cero (ej.: 1.0 / 0.0). NaN (Not a Number) representa operaciones indefinidas, como la raíz cuadrada de un número negativo o 0.0 / 0.0. Ambos tienen representaciones binarias específicas en IEEE 754 y permiten propagar errores sin interrumpir el programa, facilitando su detección posterior.

meskeIA

🔢

Conversor IEEE 754

Convierte entre decimal y punto flotante. Visualiza signo, exponente y mantisa en binario.

Términos de UsoTérminos|Política de PrivacidadPrivacidad|Contacto

Dirección

Precisión

Número Decimal

Ejemplos:

Representación IEEE 754

Signo01 bit

Exponente1000 00008 bits

Mantisa (fracción)1001 0010 0001 1111 1010 00023 bits

Valor Decimal

3.14159

Hexadecimal

0x40490FD0

Exponente

128 - 127 = 1

sesgado - sesgo = real

Tipo

Normalizado

Binario completo (32 bits)

01000000 01001001 00001111 11010000

1. Signo: positivo (0)

2. Valor absoluto: 3.14159

3. Exponente sesgado: 128 (binario: 10000000)

4. Exponente real: 128 - 127 = 1

5. Mantisa: 1001001000... (23 bits)

Referencia IEEE 754

Precisión	Total bits	Signo	Exponente	Mantisa	Sesgo	Rango aprox.
Simple (float)	32	1	8	23	127	±3.4 × 10³⁸
Doble (double)	64	1	11	52	1023	±1.8 × 10³⁰⁸

📊 Comparativa: Half vs Single vs Double (IEEE 754)

Criterio	Half (16-bit)	Single (32-bit)	Double (64-bit)
Bits totales	16	32	64
Bits exponente	5	8	11
Bits mantisa	10	23	52
Sesgo	15	127	1023
Rango máximo	±65.504	±3,4×10³⁸	±1,8×10³⁰⁸
Precisión decimal	~3-4 dígitos	~7 dígitos	~15-16 dígitos
Velocidad	Muy rápido (GPU)	Rápido	Moderado
Uso típico	ML/IA, shaders	C float, gráficos	C double, JS Number

🌍 Casos de Uso Prácticos

🎮

Motores de Videojuegos

Física y gráficos 3D usan float (32-bit). Millones de operaciones por frame. Precisión suficiente para coordenadas de pantalla.

Unity: Transform.position es float

🤖

Machine Learning / IA

Redes neuronales usan half (16-bit/bfloat16) en GPU. Reduce VRAM a la mitad. Inferencia en móvil usa float8/int8.

PyTorch: model.half()

💰

Finanzas y Banca

NUNCA usar float para dinero. 0,1 + 0,2 = 0,30000000000000004. 0,1 € × 1.000.000 transacciones = error de 4.000 €.

Usar BigDecimal o decimal

🔬

Cálculo Científico

Simulaciones físicas usan double (64-bit). NASA, CERN, meteorología. La diferencia entre float y double puede ser la diferencia entre aterrizar en Marte o no.

Siempre double en ciencia

💻

Sistemas Embebidos

Microcontroladores sin FPU usan fixed-point. Arduino evita float cuando es posible. STM32 con FPU usa float. Coste energético importante.

Fixed-point sin FPU

🌐

JavaScript y Web

Number siempre es double (64-bit). TypedArrays: Float32Array para WebGL. BigInt para enteros grandes exactos.

Number = IEEE 754 double

❓ Preguntas Frecuentes sobre Punto Flotante

¿Por qué 0,1 + 0,2 no es 0,3 exactamente?

0,1 en binario es 0,0001100110011... (periódico infinito). Al truncarse a 23 bits de mantisa, acumula error. Solución: redondear al comparar (Math.abs(a-b) < 1e-10) o usar aritmética de precisión arbitraria.

¿Cuándo usar float (32-bit) vs double (64-bit)?

Float: gráficos, física de juegos, ML donde la velocidad y memoria importan. Double: finanzas, cálculo científico, por defecto en lenguajes (JS, Python). Regla práctica: si dudas, usa double.

¿Qué es NaN y cuándo aparece?

Not a Number: resultado de 0/0, sqrt(-1), operaciones con infinito indeterminadas. NaN ≠ NaN (es la única cosa en programación que no es igual a sí misma). Verificar con Number.isNaN(x) en JavaScript.

¿Qué son los números denormalizados?

Números muy cercanos al cero (menores que 2^-126 en float). Permiten representar gradualmente el underflow en lugar de pasar directamente a cero. Más lentos en hardware por emulación software. Rango: 1,4×10⁻⁴⁵ hasta 1,2×10⁻³⁸ en float.

¿Por qué los enteros grandes pierden precisión en float?

Float tiene 23 bits de mantisa = 2²⁴ = 16.777.217 enteros exactos. A partir de ese valor, solo puede representar números pares. Por eso JS usa Number.MAX_SAFE_INTEGER = 2⁵³-1 (53 bits de mantisa en double).

¿Cómo afecta el orden de las operaciones a la precisión?

(a+b)+c ≠ a+(b+c) en punto flotante. Sumar números muy grandes y muy pequeños pierde los dígitos pequeños. El algoritmo de Kahan compensa este error en sumas de muchos números.

¿Qué diferencia hay entre +0 y -0 en IEEE 754?

Son iguales en comparación (0 === -0 en JS), pero distintos en representación binaria (bit de signo diferente). 1/+0 = +Infinity, 1/-0 = -Infinity. En JavaScript: Object.is(-0, 0) devuelve false.

¿Cómo inspeccionar los bits de un float en código?

C: union { float f; uint32_t i; }. Python: struct.pack('f', 3.14). JavaScript: usar Float32Array + Uint32Array compartiendo el mismo ArrayBuffer. Útil para debugging y optimización de bajo nivel.

📖 Guía Paso a Paso: Convertir 3,14 a IEEE 754 Single

Determinar el signo

3,14 > 0 → bit de signo = 0. Si fuera negativo, sería 1.

Convertir parte entera a binario

3 en binario = 11₂ (3 = 2 + 1)

Convertir parte decimal a binario

0,14 × 2 = 0,28 (0) → 0,28 × 2 = 0,56 (0) → 0,56 × 2 = 1,12 (1) → ... Resultado parcial: 0,001000111101...₂

Normalizar en notación científica binaria

11,001000111101...₂ = 1,1001000111101...₂ × 2¹

Calcular exponente sesgado

Exponente real = 1, sesgo = 127 → 1 + 127 = 128 = 10000000₂

Extraer mantisa (23 bits)

Parte fraccionaria de 1,1001000111101... = 10010001111010111000011₂

Combinar los tres campos

0 | 10000000 | 10010001111010111000011 = 0x4048F5C3

✅ Mejores Prácticas con Punto Flotante

🎯Usa epsilon para comparar

Math.abs(a - b) < Number.EPSILON en vez de a === b para floats

🔢Double por defecto

En caso de duda, usa double (64-bit). La diferencia de rendimiento es mínima en CPUs modernas

💶Nunca float para dinero

Usa enteros de centavos o librerías especializadas (decimal.js, big.js). 0,1 + 0,2 ≠ 0,3

🖥️Float en arrays para WebGL

Float32Array consume la mitad de memoria que Float64Array en GPU. Importante para rendimiento gráfico

⚖️Ordena las operaciones

Suma primero los números de magnitud similar. Evita (grandísimo + pequeñísimo) que pierde los dígitos pequeños

🔍Verifica NaN explícitamente

isNaN(x) en JS convierte a número antes. Usa Number.isNaN(x) para verificación exacta

⚠️Errores que Causan Bugs Difíciles de Detectar

Comparar floats con ==: 0,1 + 0,2 === 0,3 es false. Usa comparación con margen de tolerancia (epsilon)
Usar float para dinero o contabilidad: 1,005 redondeado a 2 decimales da 1,00, no 1,01. En banca esto es un bug legal
Ignorar NaN propagante: NaN + cualquier cosa = NaN. Un NaN en el pipeline de cálculo corrompe todos los resultados downstream silenciosamente
Acumular errores en bucles: Sumar 0,1 mil veces en un bucle no da 100 exactamente (da 99,9999999...)
Cast implícito double→float: Al pasar double a una función que espera float pierdes ~8 dígitos de precisión sin aviso del compilador (sin -Wall)
Asumir que float es más rápido que double: En CPUs x86-64 modernas ambos tienen el mismo rendimiento. La ventaja de float es en memoria y ancho de banda (SIMD)

🔢 ¿Qué es IEEE 754?

Estándar internacional para representar números reales en computadores. Divide el número en tres partes: signo, exponente y mantisa (fracción).

(-1)^signo × 1.mantisa × 2^exponente

📐 El Bit Implícito

En números normalizados, siempre hay un "1" implícito antes del punto decimal. Esto ahorra 1 bit de almacenamiento.

1.01011... (el 1 inicial es implícito)

⚖️ El Sesgo (Bias)

El exponente se almacena con un sesgo para evitar números negativos. Se suma el sesgo al exponente real antes de almacenarlo.

Simple: sesgo = 127
Doble: sesgo = 1023

⚠️ Números Especiales

Cero: Exp=0, Mantisa=0
Infinito: Exp=máx, Mantisa=0
NaN: Exp=máx, Mantisa≠0
Denormalizado: Exp=0, Mantisa≠0

🎯 Precisión Limitada

No todos los decimales pueden representarse exactamente. Por ejemplo, 0.1 en binario es periódico infinito.

0.1₁₀ = 0.0001100110011...₂ (infinito)

💻 En Programación

float (C/Java): precisión simple (32 bits)
double (C/Java): precisión doble (64 bits)
Number (JavaScript): siempre doble

🔗Apps relacionadas

🖥️Arquitectura ComputadorVon Neumann, CPU y ciclo FDE ⏱️Quiz ComplejidadBig O, ordenación y estructuras 📊Visualizador AlgoritmosOrdenación paso a paso 🗃️Playground SQLEditor SQL interactivo