Calculadora de complemento a dos y enteros con signo

Respuestas rápidas

¿Qué es el complemento a dos?

// -5 as an 8-bit byte, three ways to arrive at the same pattern
0b00000101        // 5
~0b00000101       // 11111010  ones' complement of 5
~0b00000101 + 1   // 11111011  two's complement = -5

// In JavaScript the width matters: bitwise operators are 32-bit,
// so anything wider has to go through BigInt.
BigInt.asIntN(8, 0xFBn)                 // -5n
BigInt.asUintN(8, -5n)                  // 251n
BigInt.asIntN(64, 0xFFFFFFFFFFFFFFFBn)  // -5n

// C23 made two's complement mandatory for signed integers.
// Before that, the other two encodings were legal but unused.

Qué hace esta calculadora

Cómo se compara con otras formas de comprobarlo

Ejemplos resueltos

-5, ancho 8

signo-magnitud     1000 0101
complemento a uno  1111 1010
complemento a dos  1111 1011  (0xFB)
binario desplazado 0111 1011

0xFB, ancho 8

sin signo          251
signo-magnitud     -123
complemento a uno  -4
complemento a dos  -5
binario desplazado 123

-128, ancho 8

signo-magnitud     sin representación
complemento a uno  sin representación
complemento a dos  1000 0000  (0x80)
binario desplazado 0000 0000

0xFFFFFFFFFFFFFF9C, ancho 64

complemento a dos -100
sin signo         18446744073709551516

Cómo usar la calculadora de complementos

1. 1

   Elige el ancho de bits

   4, 8, 16, 32 o 64. No es una preferencia de visualización: los mismos bits significan números distintos según el ancho, así que equivocarse cambia la respuesta.

2. 2

   Escribe un decimal con signo

   Teclea un número entero, con el signo negativo incluido. Las cuatro codificaciones se actualizan mientras escribes, junto con la forma hexadecimal de cada una.

3. 3

   O ve hacia atrás desde los bits

   Pega una cadena binaria o un valor 0x en el campo de decodificación para ver qué significa ese patrón exacto bajo cada interpretación, incluida la lectura sin signo.

4. 4

   Lee los avisos cuando aparezcan

   La página señala los dos casos con los que todo el mundo tropieza: el valor más negativo no tiene forma en signo-magnitud ni en complemento a uno, y el cero tiene un segundo patrón de bits en esas dos codificaciones.

Fallos que producen respuestas erróneas

5   = 00000101
~5  = 11111010   <- ones' complement, not -5

5        = 00000101
~5       = 11111010
~5 + 1   = 11111011   <- -5 in two's complement

0xFFFFFFFFFFFFFFFB        // 18446744073709552000  -- the literal is already rounded
~0xFFFFFFFFFFFFFFFB + 1   // 0  -- silently wrong, expected -5

BigInt.asIntN(64, 0xFFFFFFFFFFFFFFFBn)   // -5n

int8  0xFB  (-5)
int16 0x00FB  (251)   <- zero-extended

int8  0xFB  (-5)
int16 0xFFFB  (-5)    <- sign-extended

-128 sign-magnitude: 10000000   <- that pattern means -0

-128 sign-magnitude: no representation at width 8
-128 two's complement: 10000000

Cuándo se necesita de verdad

Leer un registro de sensor

Un registro de temperatura devuelve 0xFF9C. Sin signo eso es 65436, que no es una temperatura. Con ancho 16, la fila del complemento a dos muestra −100, y con un factor de escala de 0,1 °C el sensor te está diciendo −10,0 °C.

Depurar un protocolo con campos sin tipo

Modbus, CAN y casi toda la telemetría binaria llevan palabras en bruto sin indicación de si son con signo. Cuando un cliente y un dispositivo discrepan sobre un valor, comprobar las dos lecturas de la misma palabra suele identificar qué lado hizo la suposición equivocada.

Prácticas de estructura de computadores

Signo-magnitud, complemento a uno, complemento a dos y binario desplazado son los cuatro clásicos de un curso introductorio. Tenerlos uno al lado del otro con el mismo ancho hace las diferencias visibles en vez de memorizadas.

Perseguir un desbordamiento de entero

Cuando un contador salta de 2147483647 a −2147483648, ver ambos como patrones de 32 bits muestra que el acarreo cayó en el bit de signo. El valor no se volvió absurdo: dio la vuelta exactamente como manda la codificación.

Escribir código de serialización

Antes de fiarte de un codificador escrito a mano, comprueba un valor negativo de cada ancho contra esta página. Un fallo de signo se escribe muy fácil y produce una salida de aspecto impecable hasta que llega el primer negativo de verdad.

Cómo se construyen las cuatro codificaciones

Signo-magnitud

El bit más alto es el signo y los n−1 bits restantes son la magnitud, leída como un número sin signo normal. El rango va de −(2^(n−1)−1) a 2^(n−1)−1, simétrico y con dos ceros. Es la disposición que IEEE 754 usa para el punto flotante.

Complemento a uno

Un valor negativo es el inverso bit a bit de su magnitud, equivalentemente 2^n − 1 − x. Mismo rango y mismos dos ceros que el signo-magnitud. Su suma necesita acarreo circular, que es exactamente la complicación que el complemento a dos elimina. En inglés la posición del apóstrofo no es una errata: ones' complement se refiere a una palabra entera de unos, mientras que two's complement se refiere a una sola potencia de dos.

Complemento a dos

Un valor negativo −x se guarda como 2^n − x. El rango va de −2^(n−1) a 2^(n−1)−1, deliberadamente asimétrico y con un solo cero. La suma, la resta y la multiplicación de la palabra baja son todas ajenas al signo, y esa es toda la razón por la que ganó.

Binario desplazado

Guarda valor + 2^(n−1), de modo que −2^(n−1) queda a ceros y los patrones se ordenan igual que los valores que codifican. Equivale al patrón del complemento a dos con el bit más alto invertido. Cuidado con la nomenclatura: los campos de exponente de IEEE 754 llevan un sesgo de 2^(e−1)−1, uno menos que el desplazamiento que se usa aquí.

Por qué la aritmética usa BigInt

JavaScript convierte los operandos de &, |, ~ y los desplazamientos a enteros de 32 bits antes de operar y los reconvierte después, así que un valor de 64 bits pierde su mitad alta sin que se lance ningún error. Todas las conversiones de esta página se hacen sobre enteros de precisión arbitraria, y por eso los extremos de 64 bits salen exactos.

Tratar bien los valores con signo

Fija el ancho antes que nada

Un patrón de bits no tiene valor hasta que dices cuántos bits ocupa el campo. La mayoría de discrepancias entre una hoja de datos y un depurador se reducen a que un lado supone 16 bits y el otro 32.

Trata el valor más negativo como caso especial

Negarlo desborda en cualquier ancho: en complemento a dos, −(−128) sigue siendo −128 para un byte con signo. Todo código que calcule un valor absoluto necesita un plan para esta entrada, y toda batería de pruebas debería incluirla.

Nunca deduzcas de los datos si algo lleva signo

Ninguna inspección de los bits te dirá si un campo es con signo. Sácalo de la hoja de datos, del esquema o de la definición de la estructura; adivinar funciona hasta que llega el primer valor negativo a producción.

Extiende el signo al ampliar

Copiar un 0xFB de 8 bits a un campo de 16 como 0x00FB convierte −5 en 251. Ampliar un valor con signo significa replicar el bit de signo, lo que da 0xFFFB.

Prefiere la conversión propia del lenguaje

BigInt.asIntN en JavaScript, int.from_bytes(..., signed=True) en Python y los tipos de ancho fijo de C dicen lo que quieren decir y resuelven los bordes. El ~x + 1 hecho a mano es de donde salen los fallos de ancho.

Preguntas frecuentes