Java Language Représentation de valeur négative


Exemple

Java et la plupart des autres langages stockent des nombres intégraux négatifs dans une représentation appelée notation du complément 2 .

Pour une représentation binaire unique d'un type de données utilisant n bits, les valeurs sont codées comme suit:

Les n-1 bits les moins significatifs stockent un nombre entier positif x dans la représentation intégrale. La valeur la plus significative stocke un bit avec la valeur s . La valeur représentée par ces bits est

x - s * 2 n-1

c'est-à-dire que si le bit le plus significatif est 1, alors une valeur juste supérieure de 1 au nombre que vous pourriez représenter avec les autres bits ( 2 n-2 + 2 n-3 + ... + 2 1 + 2 0 = 2 n-1 - 1 ) est soustrait permettant une représentation binaire unique pour chaque valeur de - 2 n-1 (s = 1; x = 0) à 2 n-1 - 1 (s = 0; x = 2 n-1 - 1).

Cela a aussi l'effet secondaire agréable, que vous pouvez ajouter les représentations binaires comme s'il s'agissait de nombres binaires positifs:

v1 = x1 - s1 * 2n-1
v2 = x2 - s2 * 2n-1
s1 s2 débordement x1 + x2 résultat supplémentaire
0 0 Non x1 + x2 = v1 + v2
0 0 Oui trop grand pour être représenté avec le type de données (débordement)
0 1 Non
x1 + x2 - 2n-1 = x1 + x2 - s2 * 2n-1
= v1 + v2
0 1 Oui
(x1 + x2) mod 2n-1 = x1 + x2 - 2n-1
= v1 + v2
1 0 * voir ci-dessus (sommets de swap)
1 1 Non trop petit pour être représenté avec le type de données (x1 + x2 - 2 n <-2 n-1 ; sous - dépassement)
1 1 Oui
(x1 + x2) mod 2n-1 - 2n-1 = (x1 + x2 - 2n-1) - 2n-1
= (x1 - s1 * 2n-1) + (x2 - s2 * 2n-1)
= v1 + v2

Notez que ce fait facilite la recherche de représentation binaire de l'inverse additif (c'est-à-dire la valeur négative):

Observez que l'ajout du complément binaire au nombre a pour résultat que tous les bits sont 1. Maintenant, ajoutez 1 pour que la valeur soit dépassée et vous obtenez l'élément neutre 0 (tous les bits 0).

Donc, la valeur négative d'un nombre i peut être calculée en utilisant (en ignorant la promotion possible à int ici)

(~i) + 1

Exemple: en prenant la valeur négative de 0 ( byte ):

Le résultat de la négation 0 est 11111111 . L'ajout de 1 donne une valeur de 100000000 (9 bits). Un byte ne pouvant stocker que 8 bits, la valeur la plus à gauche est tronquée et le résultat est 00000000

Original Processus Résultat
0 (00000000) Nier -0 (11111111)
11111111 Ajouter 1 au binaire 100000000
100000000 Tronquer à 8 bits 00000000 (-0 est égal à 0)