Representación de datos

Los bits por sí mismos son simplemente estados binarios (0 y 1). Para que el hardware y el software puedan operar con ellos, necesitamos definir tipos de datos y formatos de codificación.

Una misma secuencia de 8 bits en memoria, como 01000001₂, puede interpretarse como el número entero 65, el carácter de texto 'A', una instrucción de procesador o un componente de color RGB, dependiendo del contexto.

1. Números Enteros sin Signo (Unsigned Integers) #

Cuando solo necesitamos representar cantidades positivas y el cero, todos los $n$ bits disponibles se utilizan para codificar la magnitud numérica:

$\text{Rango sin signo para } n \text{ bits: } [0,\ 2^n - 1]$

2. Números Enteros con Signo: El Complemento a Dos (C2) #

Para representar números negativos en binario, los ordenadores modernos utilizan universalmente el sistema de Complemento a Dos (Two's Complement):

$\text{Rango con signo para } n \text{ bits: } [-2^{n-1},\ 2^{n-1} - 1]$

• Para 8 bits con signo: $[-2^7,\ 2^7 - 1] = \mathbf{[-128,\ +127]}$.
• Bit más significativo (MSB): Si el primer bit por la izquierda es 0, el número es positivo; si es 1, el número es negativo.

1  01111111₂ = +127  (Máximo positivo en 8 bits)
2  00000001₂ = +1
3  00000000₂ =  0    (Existe un ÚNICO cero)
4  11111111₂ = -1    (Todos los bits a 1 representan -1)
5  10000000₂ = -128  (Mínimo negativo en 8 bits)

Algoritmo para Calcular el Complemento a Dos de un Número: #

Para transformar un número positivo en su equivalente negativo (ej. de $+5$ a $-5$ en 8 bits):

1. Escribir el número positivo en binario:
   $+5 = 00000101_2$
2. Invertir todos los bits (Complemento a Uno / NOT):
   $11111010_2$
3. Sumar $1$ al resultado:
   $11111010_2 + 00000001_2 = \mathbf{11111011}_2 = -5_{10}$

Desbordamiento Aritmético (Arithmetic Overflow) #

Ocurre cuando el resultado de una operación matemática excede el rango máximo que pueden almacenar los bits disponibles. Por ejemplo, en enteros de 8 bits con signo: $127 + 1 = -128$ (el bit de acarreo invade el bit de signo).

Antes de interpretar los bits como texto, experimenta con su interpretación como enteros con signo:

3. Codificación de Texto: ASCII, Unicode y UTF-8 #

1┌─────────────────────────────────────────────────────────────────────────────┐
2│                          EVOLUCIÓN DE LA CODIFICACIÓN                       │
3├─────────────────┬───────────────────────────────────────────────────────────┤
4│ ASCII (7 bits)  │ 128 caracteres del alfabeto inglés (A-Z, a-z, 0-9, signos)│
5├─────────────────┼───────────────────────────────────────────────────────────┤
6│ ISO-8859-1 (8b) │ 256 caracteres (Añade caracteres latinos: á, é, í, ñ, ¿) │
7├─────────────────┼───────────────────────────────────────────────────────────┤
8│ UNICODE         │ Asigna un "Code Point" numérico universal a cada símbolo  │
9│                 │ (ej. 'A' ──► U+0041, 'ñ' ──► U+00F1, '😀' ──► U+1F600)    │
10├─────────────────┼───────────────────────────────────────────────────────────┤
11│ UTF-8           │ Formato de longitud variable (1 a 4 bytes) para Unicode.   │
12│                 │ 100% compatible con ASCII y el estándar de la Web.        │
13└─────────────────┴───────────────────────────────────────────────────────────┘

Fuente: upload.wikimedia.org · Licencia: Licencia no indicada

Ampliar

Estructura de Bytes en UTF-8: #

• 1 Byte (0xxxxxxx): Caracteres ASCII estándar ($0\dots 127$). Ocupan exactamente 1 byte ('A' = 01000001).
• 2 Bytes (110xxxxx 10xxxxxx): Caracteres latinos extendidos, griegos, árabes ('á', 'ñ').
• 3 Bytes (1110xxxx 10xxxxxx 10xxxxxx): Caracteres asiáticos (chino, japonés, coreano), símbolos matemáticos.
• 4 Bytes (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx): Emojis (😀), caracteres históricos raros.

Explora primero cómo un mismo texto se convierte en puntos de código y bytes:

4. Números Reales en Coma Flotante: Estándar IEEE 754 #

Para representar números decimales extremadamente grandes o muy pequeños ($3,14159$, $6,022 \times 10^{23}$, $1,6 \times 10^{-19}$), los ordenadores utilizan el formato de Coma Flotante (Floating Point) definido por el estándar IEEE 754.

1ESTRUCTURA DE UN FLOAT DE 32 BITS (PRECISIÓN SIMPLE):
2┌──────┬────────────────────────┬─────────────────────────────────────────────┐
3│ Signo│  Exponente con Sesgo   │              Mantisa / Fracción             │
4│ 1 bit│         8 bits         │                   23 bits                   │
5└──────┴────────────────────────┴─────────────────────────────────────────────┘

• Signo ($S$): 0 para positivo, 1 para negativo.
• Exponente ($E$): Potencia de 2 escalada con un sesgo (bias).
• Mantisa ($M$): Los dígitos significativos del número normalizado en base 2 ($1.M$).

¿Por qué $0.1 + 0.2 = 0.30000000000000004$ en programación? #

En el sistema decimal, la fracción $\frac{1}{3} = 0,333333\dots$ es infinita periódica.
En el sistema binario, fracciones decimales exactas como $0.1$ ($\frac{1}{10}$) o $0.2$ ($\frac{1}{5}$) se convierten en números binarios periódicos infinitos:

$0.1_{10} = 0.0001100110011001100110011\dots_2$

Al truncar esta secuencia infinita en los 52 bits de la mantisa de un double de 64 bits, se genera un minúsculo error de redondeo acumulado.

CAUTION

Regla Crítica en Desarrollo de Software:
NUNCA utilices variables de coma flotante (float o double) para calcular dinero, transacciones bancarias, saldos o criptomonedas. Utiliza enteros (guardando céntimos) o tipos exactos de coma fija como BigDecimal (Java) o Decimal (Python/C#).

Compara números representables exactamente con números que necesitan redondeo y observa sus bits: