Calcolatore di Complemento a Due e Interi con Segno

Risposte rapide

Che cos'è il complemento a due?

// -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.

Che cosa fa questo calcolatore

Come si confronta con altri modi di verificare

Esempi svolti

-5, larghezza 8

modulo e segno     1000 0101
complemento a uno  1111 1010
complemento a due  1111 1011  (0xFB)
binario offset     0111 1011

0xFB, larghezza 8

senza segno        251
modulo e segno     -123
complemento a uno  -4
complemento a due  -5
binario offset     123

-128, larghezza 8

modulo e segno     nessuna rappresentazione
complemento a uno  nessuna rappresentazione
complemento a due  1000 0000  (0x80)
binario offset     0000 0000

0xFFFFFFFFFFFFFF9C, larghezza 64

complemento a due  -100
senza segno        18446744073709551516

Come si usa il calcolatore di complementi

1. 1

   Scegli la larghezza in bit

   4, 8, 16, 32 o 64. Non è una preferenza di visualizzazione: gli stessi bit significano numeri diversi a larghezze diverse, quindi sbagliarla cambia la risposta.

2. 2

   Inserisci un decimale con segno

   Digita un numero intero, segno negativo incluso. Le quattro codifiche si aggiornano mentre scrivi, insieme alla forma esadecimale di ciascuna.

3. 3

   Oppure parti dai bit

   Incolla una stringa binaria o un valore 0x nel campo di lettura inversa per vedere che cosa significa quel pattern esatto sotto ogni interpretazione, compresa quella senza segno.

4. 4

   Leggi le note quando compaiono

   La pagina segnala i due casi che fanno inciampare: il valore più negativo che non ha forma in modulo e segno né in complemento a uno, e lo zero che in quelle due codifiche ha un secondo pattern di bit.

Errori che producono risposte sbagliate

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

Quando serve davvero

Leggere il registro di un sensore

Un registro di temperatura restituisce 0xFF9C. Senza segno vale 65436, che non è una temperatura. Con larghezza 16 la riga del complemento a due mostra −100 e, con un fattore di scala di 0,1 °C, il sensore ti sta dicendo −10,0 °C.

Diagnosticare un protocollo con campi senza tipo

Modbus, CAN e gran parte della telemetria binaria trasportano parole grezze senza alcuna indicazione di segno. Quando un client e un dispositivo non concordano su un valore, confrontare entrambe le letture della stessa parola di solito individua quale dei due ha fatto l'assunzione sbagliata.

Esercizi di architettura degli elaboratori

Modulo e segno, complemento a uno, complemento a due e binario con offset sono le quattro codifiche standard di un corso introduttivo. Averle affiancate alla stessa larghezza rende le differenze visibili invece che da memorizzare.

Inseguire un overflow di interi

Quando un contatore salta da 2147483647 a −2147483648, vedere entrambi come pattern a 32 bit mostra che il riporto è finito nel bit di segno. Il valore non è diventato incomprensibile: è avvolto esattamente come la codifica prevede.

Scrivere codice di serializzazione

Prima di fidarti di un encoder scritto a mano, verifica su questa pagina un valore negativo per ciascuna larghezza. Un errore di segno è facilissimo da scrivere e produce un output strutturalmente sensato fino all'arrivo del primo numero negativo vero.

Come sono costruite le quattro codifiche

Modulo e segno

Il bit più alto è il segno e i restanti n−1 bit sono il modulo, letto come un normale numero senza segno. L'intervallo va da −(2^(n−1)−1) a 2^(n−1)−1, è simmetrico e ha due zeri. È il layout che IEEE 754 usa per la virgola mobile.

Complemento a uno

Un valore negativo è l'inverso bit a bit del suo modulo, cioè 2^n − 1 − x. Stesso intervallo e stessi due zeri del modulo e segno. L'addizione richiede il riporto circolare, che è esattamente la complicazione eliminata dal complemento a due. In inglese la posizione dell'apostrofo non è un refuso: ones' complement è riferito a una parola di tutti uno, mentre two's complement è riferito a una singola potenza di due.

Complemento a due

Un valore negativo −x è memorizzato come 2^n − x. L'intervallo va da −2^(n−1) a 2^(n−1)−1, è volutamente asimmetrico e ha un solo zero. Addizione, sottrazione e moltiplicazione della parola bassa sono tutte indipendenti dal segno, e questa è l'intera ragione per cui ha vinto.

Binario con offset

Memorizza value + 2^(n−1), così −2^(n−1) diventa tutto zeri e i pattern si ordinano nello stesso ordine dei valori che codificano. Equivale al pattern in complemento a due con il bit più alto invertito. Attenzione al nome: i campi esponente di IEEE 754 sono polarizzati di 2^(e−1)−1, uno in meno dell'offset usato qui.

Perché l'aritmetica usa BigInt

JavaScript converte gli operandi di &, |, ~ e degli scorrimenti in interi a 32 bit prima di operare e li riconverte dopo, quindi un valore a 64 bit perde la metà alta senza che venga sollevato alcun errore. Ogni conversione di questa pagina è invece eseguita su interi a precisione arbitraria, ed è anche il motivo per cui gli estremi a 64 bit risultano esatti.

Gestire correttamente i valori con segno

Fissa la larghezza prima di ogni altra cosa

Un pattern di bit non ha valore finché non dici quanto è largo il campo. La maggior parte dei disaccordi tra un datasheet e un debugger si riduce a una parte che assume 16 bit e l'altra 32.

Tratta il valore più negativo come un caso speciale

Negarlo va in overflow a qualsiasi larghezza: in complemento a due −(−128) resta −128 per un byte con segno. Qualsiasi codice che calcola un valore assoluto ha bisogno di un piano per questo input, e qualsiasi suite di test dovrebbe contenerlo.

Non dedurre mai la presenza del segno dai dati

Nessuna ispezione dei bit può dirti se un campo è con segno. Ricavalo dal datasheet, dallo schema o dalla definizione della struct; tirare a indovinare funziona fino al primo valore negativo in produzione.

Estendi il segno quando allarghi

Copiare un 0xFB a 8 bit in un campo a 16 bit come 0x00FB trasforma −5 in 251. Allargare un valore con segno significa replicare il bit di segno, ottenendo 0xFFFB.

Preferisci la conversione nativa del linguaggio

BigInt.asIntN in JavaScript, int.from_bytes(..., signed=True) in Python e i tipi a larghezza fissa in C dicono quello che intendono e gestiscono i casi limite. È il ~x + 1 scritto a mano a generare i bug di larghezza.

Domande frequenti