La calculatrice binaire effectue l'ensemble complet des opérations dont les développeurs ont besoin sur des nombres en base 2 : arithmétique (addition, soustraction, multiplication, division, exponentiation), logique bit à bit (AND, OR, XOR, NOT) et opérateurs de décalage (left shift, right shift). Chaque résultat est affiché en même temps en binaire, décimal et hexadécimal pour que vous puissiez vérifier à la main ou copier directement dans le code source. Les entrées peuvent être saisies dans n'importe laquelle des trois bases — pratique quand vous avez une constante hex d'une fiche technique, une valeur décimale d'une spécification ou un littéral binaire d'un bitmap — et l'arithmétique à précision arbitraire via BigNumber.js élimine les plafonds de débordement à 32 ou 53 bits. Usages courants : déboguer les opérations sur flags, construire des masques réseau, décoder des registres matériels, calculer des valeurs en complément à deux et apprendre comment l'ordinateur calcule vraiment.
Qu'est-ce que le binaire ?
Le binaire est le système numérique que les ordinateurs utilisent réellement. Il a exactement deux symboles, 0 et 1, parce que le matériel physique — transistors, domaines magnétiques, puits optiques — peut représenter de manière fiable deux états distincts (éteint/allumé, basse/haute tension) et presque rien d'autre avec la même vitesse et la même fiabilité. Toute structure de plus haut niveau en informatique — texte, images, audio, paquets réseau, instructions — n'est, au niveau le plus bas, que des bits.
Chaque chiffre binaire s'appelle un bit. Huit bits forment un octet (la plus petite unité adressable individuellement sur presque tous les ordinateurs modernes) ; 16 bits un demi-mot ; 32 ou 64 bits un mot, correspondant à la largeur de registre native du CPU. Dans un octet, les bits sont numérotés de 0 (le moins significatif, à droite) à 7 (le plus significatif, à gauche). Le bit en position k contribue à 2^k quand il est activé.
Le binaire est un système positionnel comme le décimal, mais en base 2 plutôt qu'en base 10. Le nombre binaire 1010 se développe en 1×2³ + 0×2² + 1×2¹ + 0×2⁰ = 8 + 0 + 2 + 0 = 10 en décimal. Le chiffre de tête est le plus significatif — même convention qu'en décimal. Pour convertir du décimal en binaire, divisez successivement par 2 et notez les restes du bas vers le haut ; pour convertir du binaire en décimal, additionnez les puissances de 2 à chaque bit activé.
L'importance du binaire n'est pas seulement historique : toute primitive de calcul — arithmétique, adresses, formats de fichier, protocoles réseau — est définie en termes de bits et d'alignement d'octets. Comprendre le binaire directement, c'est ce qui permet à un développeur de raisonner sur le débordement, l'alignement, l'endianness, la compression et le coût des opérations. Même les langages de haut niveau qui cachent les bits les exposent quand la performance compte (bitsets, filtres de Bloom, RoaringBitmap, sommes CRC, fonctions de hachage).
Comment effectuer des calculs binaires ?
L'arithmétique binaire suit le même algorithme colonne par colonne que vous avez appris pour le décimal — la seule différence est que l'alphabet a deux symboles au lieu de dix, donc les règles de retenue/emprunt sont plus serrées.
- Addition binaire
- Même algorithme par colonnes qu'en décimal, mais la plus grande somme à un seul chiffre est 1 + 1 = 10₂ (soit 2 en décimal, écrit 0 dans cette colonne avec un 1 retenu à gauche).
- Règles à une colonne : 0+0=0, 0+1=1, 1+0=1, 1+1=10 (retenue 1). Avec une retenue entrante : 1+1+1=11 (écrire 1, retenue 1).
- Exemple : 1011 (11) + 1101 (13) = 11000 (24). Vérifiez en additionnant colonne par colonne de la droite vers la gauche avec les retenues.
- Le matériel additionne des binaires exactement ainsi avec des additionneurs complets en cascade ; les CPU modernes additionnent une paire de 64 bits en un cycle d'horloge en calculant toutes les retenues en parallèle (carry-lookahead).
- Soustraction binaire
- Règles de colonne pour la soustraction : 0-0=0, 1-0=1, 1-1=0, 0-1 nécessite un emprunt à la colonne suivante (donne 1 dans cette colonne, soustrait 1 à la colonne de gauche).
- Dans les CPU, la soustraction n'est presque jamais réalisée par un circuit d'emprunt séparé. À la place, a-b est calculé comme a + (~b + 1) — addition avec le complément à deux de b — en utilisant le même additionneur.
- Exemple : 1011 (11) - 100 (4) = 111 (7). Ou via le complément à deux : ~100 + 1 sur 4 bits = 1100, puis 1011 + 1100 = 10111, on jette le bit de sortie, il reste 0111 = 7.
- C'est pourquoi les entiers en C, Java et la plupart des langages peuvent boucler silencieusement au-delà de INT_MIN/INT_MAX : a + 1 boucle vers INT_MIN quand a == INT_MAX car le bit de sortie est jeté.
- Multiplication binaire
- Chaque bit du multiplicateur est multiplié par le multiplicande entier et les produits partiels sont sommés, décalés selon la position du bit.
- Règles à un bit : 0×n'importe quoi=0, 1×n'importe quoi=cette chose (il suffit de copier).
- Exemple : 101 (5) × 11 (3) = produits partiels 101 (×1) et 1010 (×2, décalé d'une place à gauche) sommés = 1111 (15).
- Le matériel fait cela avec un circuit multiplieur ; multiplier deux valeurs de 64 bits prend généralement quelques cycles sur x86 moderne (IMUL), mais coûtait cher sur les premiers CPU — bien plus lent que l'addition. C'est pourquoi de nombreuses anciennes bases de code utilisent des astuces de shift-and-add.
- Quand un opérande est une puissance de 2, la multiplication dégénère en un décalage à gauche (n × 8 == n << 3). Les compilateurs le font automatiquement comme réduction de force ; idem pour la division par une puissance de 2, qui devient un décalage à droite.
- Division binaire
- La division longue binaire procède bit par bit : décale le diviseur pour l'aligner sur les bits hauts du dividende, soustrait s'il rentre (en écrivant 1 dans le quotient), décale à droite, recommence. Le reste est ce qui subsiste après la dernière soustraction.
- Notes pratiques
- Écrire les valeurs de position au-dessus des colonnes (..., 16, 8, 4, 2, 1) est le moyen le plus rapide de convertir du binaire en décimal à la main. Chaque '1' apporte sa valeur de position ; on les additionne.
- Utilisez l'hex comme notation intermédiaire : tous les 4 chiffres binaires correspondent à 1 chiffre hex, donc 1010 1011 = 0xAB, sans calcul. C'est pourquoi les dumps mémoire et les codes couleur utilisent l'hex.
- Attention à la taille de mot quand vous calculez dans un vrai langage : les opérateurs bit à bit de JavaScript tronquent silencieusement les opérandes en entiers signés 32 bits, donc tout calcul impliquant les bits 31+ se comporte de façon surprenante. Cette calculatrice utilise BigNumber.js pour éviter cela.
Au-delà de la pratique manuelle et de cette calculatrice, tout langage de programmation généraliste prend en charge les littéraux binaires (0b1010 en JS, Python, Rust, C++14+) et un jeu complet d'opérateurs bit à bit. Pour le travail embarqué, consultez la fiche technique de votre puce — les agencements de bits des registres sont presque toujours définis en binaire.
Tableau de conversion binaire/décimal
| Binaire | Décimal |
|---|
| 0000 | 0 |
| 0001 | 1 |
| 0010 | 2 |
| 0011 | 3 |
| 0100 | 4 |
| 0101 | 5 |
| 0110 | 6 |
| 0111 | 7 |
| 1000 | 8 |
| 1001 | 9 |
| 1010 | 10 |
| 1011 | 11 |
| 1100 | 12 |
| 1101 | 13 |
| 1110 | 14 |
| 1111 | 15 |
Questions fréquentes
Parce que le binaire n'a que deux symboles, 0 et 1 — le symbole « 2 » n'existe tout simplement pas dans ce système. Dès que vous atteignez un compte de deux dans n'importe quel système positionnel, il faut passer à la valeur positionnelle suivante. En décimal, 9 + 1 = 10 pour exactement la même raison : 9 est le dernier symbole à un seul chiffre, et ajouter 1 force une retenue dans la colonne des dizaines. En binaire, 1 + 1 produit 0 dans la colonne des unités et reporte 1 dans la colonne des deux, écrit 10. La valeur est deux — seule la notation change. C'est aussi pourquoi les programmeurs plaisantent : « il y a 10 sortes de gens dans le monde : ceux qui comprennent le binaire et ceux qui ne le comprennent pas ». Tous les systèmes positionnels fonctionnent ainsi, hexadécimal compris : F + 1 = 10 (seize), et ternaire : 2 + 1 = 10 (trois).
Le complément à deux est la représentation universelle des entiers signés dans le matériel moderne, et il fonctionne en réinterprétant le bit le plus significatif (MSB) avec un poids négatif. Sur 8 bits, le MSB pèse −128 au lieu de +128. Ainsi 11111111 en complément à deux vaut −128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = −1, et 10000000 vaut exactement −128. Pour négativer un nombre : inversez tous les bits (complément à un) et ajoutez 1. Exemple : +5 = 00000101 → inversion 11111010 → +1 = 11111011 = −5. Le complément à deux a trois propriétés qui ont conduit à son adoption universelle : (1) il n'y a qu'un seul zéro (00000000), pas deux comme en signe-magnitude ; (2) l'addition fonctionne pareillement pour signés et non signés — le même additionneur gère les deux ; (3) le bit de sortie du bit haut est jeté, ce qui donne une arithmétique modulaire naturelle et un débordement prévisible. Compromis : la plage négative est plus grande d'un cran que la plage positive (8 bits : −128 à +127), et abs(INT_MIN) déborde.
Les opérateurs bit à bit ne sont pas des curiosités académiques — ils apparaissent en permanence dans le code performant, le code système et les protocoles. AND (&) teste des bits et applique des masques : status & 0x04 vérifie si le troisième bit est positionné, motif courant pour lire des flags d'état ou extraire des champs d'une structure compactée. OR (|) active des bits : flags = flags | LOG_INFO active un flag sans toucher aux autres. XOR (^) bascule des bits ou détecte des différences : x ^ x vaut toujours 0, utilisé dans les sommes de contrôle ; XOR-swap échange deux variables sans variable temporaire ; chiffrement XOR avec une clé. NOT (~) inverse tous les bits et s'utilise surtout avec AND pour effacer des bits spécifiques : flags = flags & ~LOG_DEBUG éteint LOG_DEBUG sans toucher aux autres. Ces quatre opérations sont aussi les briques d'abstractions plus hautes : bitmaps, filtres de Bloom, RoaringBitmap, masques IP (ip & netmask donne l'adresse réseau), mélange de couleurs en graphisme, et fonctions de hachage. Presque tous les CPU les implémentent en instructions à un cycle ; dans les boucles serrées, elles battent toute alternative conditionnelle.
Le décalage à gauche (<<), quel que soit le type, est sans ambiguïté : on bourre de zéros à droite, on jette les bits à gauche. À droite, il y a deux variantes et il faut savoir laquelle. Logique (>>> en JavaScript et Java, lsr sur ARM) : bourre toujours de 0 à gauche, traitant le nombre comme non signé — 0xFF >>> 1 = 0x7F. Arithmétique (>> en JavaScript, Java, C avec types signés ; asr sur ARM) : recopie le bit de signe, préservant le signe d'un nombre en complément à deux — −2 >> 1 = −1, pas 0x7FFFFFFE. C'est important : pour des champs non signés, utilisez le logique ; pour des entiers signés, l'arithmétique. La rotation (pas d'opérateur natif en C ni JS, intrinsèques _rotl/_rotr sur x86) fait tourner les bits d'un bout à l'autre au lieu de les jeter — utile en cryptographie (AES, ChaCha utilisent des rotations) et dans les fonctions de hachage de largeur fixe où il faut une bonne dispersion. Le << ordinaire de JavaScript tronque silencieusement à 32 bits, donc les décalages au-delà du bit 31 surprennent ; cette calculatrice utilise BigNumber.js pour rester exacte à n'importe quelle largeur.
Parce que 4 chiffres binaires correspondent exactement à 1 chiffre hex, sans reste. 0000 à 1111 ↔ 0 à F. Une valeur 32 bits, ce sont 32 chiffres binaires mais seulement 8 chiffres hex, qui tiennent sur une ligne de code source et se lisent d'un coup d'œil. L'hex préserve toute la structure binaire : chaque caractère hex dit exactement 4 bits, donc 0xDEADBEEF révèle aussitôt le motif binaire au lecteur, alors que 11011110101011011011111011101111 brouille l'œil. L'octal (base 8) est plus ancien et groupe les bits par 3 — courant sur les machines 12 et 36 bits des années 1960 — mais il ne divise pas 32 proprement et laisse des trous gênants ; l'hex a gagné. Les codes couleur RGB (#FF8800), les adresses MAC, les UUID, les adresses mémoire, les sommes de contrôle et les points de code Unicode (U+1F600) sont tous en hex pour cette raison. Quand on débogue du code au niveau du bit, apprendre à traduire à vue les chiffres hex en motifs binaires de 4 bits est l'une des compétences à plus fort levier.
Parce que le décimal 0,1 n'a pas de représentation binaire exacte. En base 2, 0,1 est la fraction périodique non terminée 0,000110011001100... — analogue à 1/3 = 0,333... en décimal. IEEE 754 double précision arrondit cela à 52 bits de mantisse, donnant une approximation légèrement supérieure à 0,1. Idem pour 0,2. Quand vous additionnez les deux approximations arrondies et reconvertissez en décimal, l'erreur résiduelle devient visible : 0,30000000000000004. Les puissances de 2 — 0,5, 0,25, 0,125 — et leurs multiples entiers — 0,75, 0,625 — sont exactement représentables. Tout le reste a une erreur d'arrondi. Pour des calculs financiers ou quand une arithmétique décimale exacte est requise, utilisez une bibliothèque décimale (BigDecimal en Java, Decimal en Python, BigNumber.js en JavaScript) ou mettez à l'échelle en centimes entiers. Pour l'arithmétique entière binaire — ce sur quoi se concentre cette calculatrice — il n'y a pas d'erreur d'arrondi : les entiers jusqu'à 2^53 tiennent exactement dans un double, et BigNumber.js nous emmène encore plus loin.
Cela dépend du langage et du type entier. Le int de C/C++ est laissé à l'implémentation mais c'est en général 32 bits signés : −2 147 483 648 à +2 147 483 647 (environ ±2,1 milliards). long long fait 64 bits signés : environ ±9,2 trillions. Le Number de JavaScript est un double IEEE 754 64 bits, donc il représente exactement les entiers jusqu'à 2^53 − 1 = 9 007 199 254 740 991 (Number.MAX_SAFE_INTEGER) ; au-delà, les entiers consécutifs ne sont plus distinguables. Les opérateurs bit à bit de JavaScript (&, |, ^, <<, >>, ~) trichent autrement : ils tronquent toujours les deux opérandes en entiers signés 32 bits, puis reconvertissent en Number. D'où 0x100000000 | 0 == 0, ce qui surprend. ES2020 a ajouté BigInt (littéral 123n) pour la précision arbitraire. Python a un int de précision arbitraire natif — pas de débordement — mais paie un coût à l'exécution. Rust force le choix : u32, i64, u128, etc., et le débordement est vérifié en debug mais boucle en release. Cette calculatrice utilise BigNumber.js pour une précision arbitraire, donc l'arithmétique binaire à des centaines de chiffres se comporte comme prévu.
L'usage de motifs binaires en mathématiques remonte bien avant Leibniz — la multiplication égyptienne antique utilisait une décomposition binaire, et le savant indien Pingala a décrit autour de 200 av. J.-C. ce qui équivaut à un système positionnel binaire pour analyser la métrique sanskrite. Mais Gottfried Wilhelm Leibniz, dans son article de 1703 Explication de l'Arithmétique Binaire, a donné le premier traitement systématique occidental du binaire comme système numérique complet, avec règles d'addition, de soustraction, de multiplication et de division — et a explicitement observé que tous les nombres pouvaient être représentés avec seulement 0 et 1. Leibniz s'est partiellement inspiré de descriptions des hexagrammes du Yi Jing, dont les 64 figures correspondent exactement à des nombres binaires sur 6 bits. Le saut suivant a pris 250 ans : l'algèbre de la logique de George Boole en 1854 a montré que les propositions pouvaient être manipulées avec deux valeurs de vérité, et la thèse de master au MIT de Claude Shannon en 1937, A Symbolic Analysis of Relay and Switching Circuits, a prouvé que l'algèbre booléenne implémentée sur des relais électriques pouvait réaliser un calcul arbitraire — la base de tous les ordinateurs numériques. Le Z3 de Konrad Zuse (1941) et l'ENIAC (1945) ont suivi peu après. Chaque CPU aujourd'hui n'est, au final, qu'une immense machine à circuits booléens suivant le plan de Shannon.
Calcul
Math
Vous avez des commentaires ? Signalez des bugs, suggérez des fonctionnalités ou partagez vos idées — nous lisons tout
CALCULATRICES MATHéMATIQUES32
OUTILS DéVELOPPEUR99
WUTOOLS