Calculer le complément à deux
Convertissez dans les deux sens à largeur fixe : -18 sur 8 bits donne 11101110, et lire 11101110 sur 8 bits redonne -18, avec des largeurs de 2 à 53 bits et sans débordement silencieux. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Le complément à deux est la représentation de largeur fixe habituelle des entiers signés dans les processeurs, les formats de fichiers, les registres et les protocoles réseau. Ce convertisseur fonctionne dans les deux sens : indiquez un entier et une largeur en bits pour obtenir le motif binaire exact, ou fournissez un motif binaire et sa largeur pour retrouver l’entier signé. Chaque requête est contrôlée au lieu de tronquer discrètement les valeurs hors plage. Le résultat convient donc à l’apprentissage, au débogage, à la documentation et aux jeux de tests automatisés, lorsqu’un seul bit de signe peut modifier tout un champ.
Choisissez la largeur avant la conversion
Une valeur en complément à deux n’a de sens que si sa largeur est connue. Les mêmes bits de fin peuvent désigner des valeurs différentes selon qu’ils sont lus comme un mot de huit, seize ou trente-deux bits, car le bit le plus à gauche de la largeur retenue indique le signe. Commencez par choisir une largeur de 2 à 53 bits, puis le sens de conversion.
Pour passer d’un entier au binaire, saisissez un nombre entier signé. Le convertisseur vérifie la plage légale, de moins deux puissance bits moins un à deux puissance bits moins un, moins un. Un mot de huit bits accepte ainsi les valeurs de -128 à 127.
Si l’entier sort de cette plage, la requête renvoie une erreur de saisie plutôt que de supprimer les bits de poids fort ou de produire un bouclage trompeur. Ce contrôle strict est précieux pour vérifier des définitions de registres, des limites de sérialiseurs, des exercices et des structures de données. Un résultat valide contient toujours exactement le nombre demandé de chiffres, y compris les zéros initiaux des valeurs positives et les uns initiaux nécessaires aux valeurs négatives de largeur fixe.
Comprenez le codage et le décodage
Pour un entier positif ou nul, le codage emploie la notation ordinaire en base deux et ajoute des zéros à gauche jusqu’à la largeur choisie. Pour un entier négatif, le convertisseur ajoute la valeur à deux élevé à la largeur, puis écrit ce résidu positif en binaire. Cette définition modulaire équivaut à la méthode manuelle consistant à inverser tous les bits de la valeur positive et à ajouter un, mais elle évite les cas particuliers et exprime directement le calcul.
Le décodage applique la règle inverse. Le convertisseur lit d’abord la chaîne comme une quantité non signée. Si son premier bit vaut zéro, cette quantité est déjà la réponse signée.
S’il vaut un, il soustrait deux élevé à la largeur afin de retrouver la valeur négative. L’entrée binaire ne peut contenir que des zéros et des uns et doit avoir exactement la longueur déclarée. La largeur n’est jamais devinée, aucun remplissage n’est ajouté au décodage et aucun chiffre excédentaire n’est coupé.
Ainsi, chaque entier accepté donne un motif unique dont le décodage à la même largeur restitue la valeur initiale.
Employez des représentations exactes en pratique
Cette capacité est utile dès qu’une valeur décimale lisible doit être comparée à un champ signé de bas niveau. Les équipes de micrologiciel peuvent vérifier les écarts de capteurs, les registres d’état et les exemples de protocoles avant de les intégrer à leur documentation. Les développeurs d’applications peuvent créer des valeurs de référence pour l’empaquetage d’octets signés, tester les limites et déterminer si une grande valeur non signée inattendue représente en réalité un nombre négatif en complément à deux.
Les étudiants peuvent contrôler leur calcul tout en voyant le motif complet de largeur fixe, plutôt qu’une écriture binaire abrégée qui masque l’extension du signe. Le calcul est déterministe, local au moteur d’analyse, sans modèle, service externe, hasard ni horloge. Conservez la largeur indiquée par le format de stockage étudié.
Si un protocole définit un champ sur douze bits, décodez les douze chiffres, y compris les zéros ou les uns initiaux.
Cas d’usage
Contrôler des registres signés
Transformez les limites et exemples décimaux documentés en motifs de largeur exacte pour la revue du matériel et du micrologiciel.
Créer des jeux de tests de sérialisation
Produisez des résultats binaires stables pour les valeurs positives, négatives, minimales, maximales et nulles.
Décoder des captures de protocole
Interprétez un champ binaire de largeur fixe comme l’entier signé prévu par la spécification du protocole.
Questions fréquentes
Quelle plage tient dans une largeur donnée ?
Une largeur de w bits conserve les entiers signés de -2^(w-1) à 2^(w-1)-1.
Pourquoi l’entrée binaire doit-elle avoir exactement la largeur indiquée ?
Le premier bit de cette largeur détermine le signe ; deviner ou compléter discrètement la largeur pourrait donc modifier le résultat.
Que se passe-t-il quand un entier ne tient pas dans la largeur ?
Vous obtenez une erreur claire au lieu d’un résultat replié ou tronqué. Un mot de 8 bits, par exemple, n’accepte que -128 à 127 : une valeur hors de cette plage est refusée plutôt que de perdre ses bits de poids fort.
Comment un nombre négatif est-il codé ?
La valeur est ajoutée à deux élevé à la largeur, puis le résultat est écrit en binaire. Cela revient à inverser tous les bits du nombre positif et à ajouter un, d’où 11101110 pour -18 sur 8 bits.
Comment retrouver un nombre à partir d’une suite de bits ?
Les bits sont d’abord lus comme un nombre non signé. Si le bit de gauche vaut zéro, c’est déjà la réponse ; s’il vaut un, on soustrait deux élevé à la largeur, si bien que 11101110 sur 8 bits donne -18.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/dev2/two-complement-convert \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"mode":"integer_to_binary","bits":8,"integer":-18,"binary":"11101110"}'const res = await fetch("https://api.kit.forhosting.com/dev2/two-complement-convert", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"mode": "integer_to_binary",
"bits": 8,
"integer": -18,
"binary": "11101110"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev2/two-complement-convert",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"mode": "integer_to_binary",
"bits": 8,
"integer": -18,
"binary": "11101110"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev2/two-complement-convert", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"mode":"integer_to_binary","bits":8,"integer":-18,"binary":"11101110"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"mode":"integer_to_binary","bits":8,"integer":-18,"binary":"11101110"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev2/two-complement-convert", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"mode": "integer_to_binary",
"bits": 8,
"integer": -18,
"binary": "11101110"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev2.two_complement_convert",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Limites
min_bits | 2 |
max_bits | 53 |
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Employez des représentations exactes en pratique
Pour automatiser, envoyez le mode, la largeur et le champ entier ou binaire concerné par l’API ; chaque élément réussi utilise le tarif de base publié de $0.002.
Questions techniques
Que se passe-t-il si l’entier ne tient pas ?
La conversion échoue avec une erreur invalid_input qui précise la plage autorisée. La valeur n’est jamais bouclée ni tronquée.
La conversion fonctionne-t-elle dans les deux sens ?
Oui. Utilisez integer_to_binary pour coder un entier signé et binary_to_integer pour décoder un motif de largeur fixe.
Quel est le prix d’une requête API ?
Chaque élément API réussi utilise le tarif de base publié de $0.002. Une entrée incorrecte est refusée avant tout résultat valide.