Bonjour ,

Tout système numérique (binaire, octal, décimal, hexadécimal, et autres) répond à une structure identique , constitué de digits dont les bits de poids fort (MSB = Most Significant Bit) se trouvent à l’extrême gauche et les bits de poids faibles (LSB = Least Significant Bit) à l’extrême droite .

Prenons une date en décimal par exemple : 1984
Le nombre est composé de 4 Digits (1,9,8 et 4) et occupe donc 4 rangs , avec 1 en MSB (bit de poids fort) et 4 en LSB (bit de poids faible) .

Décomposons le : 1 x 1000 + 9 x 100 + 8 x 10 + 4 x 1 = 1984
ou d’une autre façon : 4 x 1 + 8 x 10 + 9 x 100 + 1 x 1000 = 1984
Peu importe l’ordre de traitement , l’important c’est que chaque digit garde son poids (son rang) dans le nombre .

La structure des nombres est la suivante : Digit x Base ^ (Rang – 1)

En binaire , Base = 2
En octal , Base = 8
En décimal , Base = 10
En hexadécimal , Base = 16

Reprenons la décomposition décimale du nombre dans cette structure :
1 x 10³ + 9 x 10² + 8 x 10¹ + 4 x 10⁰ = 1984


— - Si 1984 avait été de l’hexadécimal , il aurait fallut l’indiquer par un préfixe (&h, 0h, 0x, etc) avec h ou x pour hexadécimal .
Chaque digit est alors un Nibble (mot de 4 bits) .

NB : Un octet est composé de deux Nibbles .
l’IPv6 est composés de Digits notés en Nibbles hexadécimaux (digits de 0 à 9 et A à F) .
Contrairement à l’IPv4 qui lui est en suites d’Octets décimaux (0 à 255) .

0x1984 = 0x1 x 16³ + 0x9 x 16² + 0x8 x 16¹ + 0x4 x 16⁰ = 6532
En binaire décomposer chaque digit par son équivalent Nibble :
0x1 = 0b0001 = 2⁰ = 1
0x9 = 0b1001 = 2³ + 2⁰ = 9
0x8 = 0b1000 = 2³ = 8
0x4 = 0b0100 = 2² = 4
soit 0b0001 1001 1000 0100 = 2¹² + 2¹¹ + 2⁸ + 2⁷ + 2² = 6532


— - Pour convertir 1984 en binaire , il faut créer un décalage de bit vers la droite par une succession de divisions afin de récupérer le modulo (reste de division entière) .
1984 / 2 = 992,0 => 992 reste 0 à 2⁰
992 / 2 = 496,0 => 496 reste 0 à 2¹
496 / 2 = 248,0 => 248 reste 0 à 2²
248 / 2 = 124,0 => 124 reste 0 à 2³
124 / 2 = 62,0 => 62 reste 0 à 2⁴
62 / 2 = 31,0 => 31 reste 0 à 2⁵
31 / 2 = 15,5 => 15 reste 1 à 2⁶
15 / 2 = 7,5 => 7 reste 1 à 2⁷
7 / 2 = 3,5 => 3 reste 1 à 2⁸
3 / 2 = 1,5 => 1 reste 1 à 2⁹
1 / 2 = 0,5 => 0 reste 1 à 2¹⁰
0 / 2 = 0,0 => 0 reste 0 à 2¹¹

Soit 0b11111000000
Qu’on décompose comme suit avec ces 11 Digits  :
1x2¹⁰ + 1x2⁹ + 1x2⁸ + 1x2⁷ + 1x2⁶ + 0x2⁵ + 0x2⁴ + 0x2³ + 0x2² + 0x2¹ + 0x2⁰ = 1984

ou plus simplement en indiquant juste les poids actifs (bits à 1)  :
2¹⁰ + 2⁹ + 2⁸ + 2⁷ + 2⁶ = 1984

NB : Les digits à zéro peuvent être omis dans tous système numérique .

- Pour faire un décalage de bit à droite , avec une calculatrice ne gérant pas le modulo , lorsque la division se termine par 0,5 , soit la moitié de 1 , on a affaire au bit 1 , dans le cas contraire , lorsque qu’il s’agit du bit 0 , il n’y a pas de décimales .
Il faut juste penser à reporter la valeur entière (sans les décimales) pour la suite des calculs ,

— - On aurait tout aussi bien pu décodé le binaire en faisant un décalage de bits à gauche !!!

Déterminer le bit de limite :
2^10 = 1024 < 1984 , bit juste en dessous .
2^11 = 2048 > 1984 , bit juste au dessus .

Commençons le calcul avec le bit juste au dessus :
1984 x 2 = 3968 => 3968 ≥ 2048 = Vrai => 0b1 x 2¹⁰ => 3868 – 2048 = 1920
1920 x 2 = 3840 => 3840 ≥ 2048 = Vrai => 0b1 x 2⁹ => 3840 – 2048 = 1792
1792 x 2 = 3584 => 3584 ≥ 2048 = Vrai => 0b1 x 2⁸ => 3584 – 2048 = 1536
1536 x 2 = 3072 => 3072 ≥ 2048 = Vrai => 0b1 x 2⁷ => 3072 – 2048 = 1024
1024 x 2 = 2048 => 2048 ≥ 2048 = Vrai => 0b1 x 2⁶ => 2048 – 2048 = 0
0 x 2 = 0
Quand il reste zéro , il n’y a plus de bits à découvrir , fin du calcul .

Ou le calcul avec le bit juste en dessous :
1984 ≥ 1024 = Vrai => 0b1 x 2¹⁰ => (1984 – 1024) x 2 = 1920
1920 ≥ 1024 = Vrai => 0b1 x 2⁹ => (1920 – 1024) x 2 = 1792
1792 ≥ 1024 = Vrai => 0b1 x 2⁸ => (1792 – 1024) x 2 = 1536
1536 ≥ 1024 = Vrai => 0b1 x 2⁷ => (1536 – 1024) x 2 = 1024
1024 ≥ 1024 = Vrai => 0b1 x 2⁶ => (1024 – 1024) x 2 = 0
0 ≥ 1024 = Faux => 0 x 2 = 0

Quand il reste zéro , il n’y a plus de bits à découvrir , fin du calcul .

J’espère que l’auteur ne se perdra plus dans ses conversions de bases !