Calculatrice addition saturée
Additionnez deux entiers en gardant la somme dans une largeur de bits fixe : 100 + 50 dans un mot signé de 8 bits donne 127 au lieu de reboucler vers un négatif, et la somme exacte, 150, s'affiche à côté. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- A
- 100
- B
- 50
- Bits
- 8
- Résultat
- 127
- Min
- -128
- Max
- 127
- Somme exacte
- 150
L'addition entière saturée borne la somme mathématique de deux entiers aux valeurs extrêmes qui tiennent encore dans un mot de largeur fixe choisie, au lieu de tourner comme le fait l'arithmétique modulaire et la plupart des types entiers machine. Les ingénieurs qui vérifient des noyaux DSP, des formules de dégâts de jeu, des canaux de couleur et des compteurs de sécurité ont besoin de ce comportement de bornage avec un minimum et un maximum exacts et un indicateur saturé sans ambiguïté. Les étudiants qui comparent le débordement par enroulement à la saturation ont besoin d'un oracle déterministe qui n'invente jamais un résultat modulaire. Ce calculateur d'addition saturée d'entiers accepte les opérandes a et b, une largeur de bits de deux à soixante-quatre et un indicateur signé optionnel, puis renvoie le résultat borné, la somme exacte non bornée, l'intervalle représentable et si une saturation par débordement ou sous-débordement s'est produite.
Ce que signifie l'addition saturée face au débordement par enroulement
L'addition entière ordinaire à largeur fixe est modulaire : lorsque la vraie somme quitte l'intervalle représentable, le résultat machine s'enroule en réduisant la somme modulo deux à la puissance de la largeur, ce qui peut sauter d'une grande valeur positive à une grande valeur négative ou d'un juste en dessous de zéro à une grande positive.
L'addition saturée adopte une autre politique que préfèrent de nombreux jeux d'instructions DSP, codecs multimédias et compteurs de sécurité critique : si la vraie somme dépasse le maximum représentable, le résultat devient ce maximum ; si elle est inférieure au minimum, le résultat devient ce minimum ; sinon le résultat est égal à la vraie somme. Aucun enroulement modulaire n'a lieu.
Pour une largeur signée de w bits l'intervalle fermé va de moins deux à la puissance w moins un jusqu'à deux à la puissance w moins un, moins un — l'intervalle classique en complément à deux de int8, int16 et int32. Pour une largeur non signée w l'intervalle va de zéro à deux à la puissance w moins un.
Ce calculateur met en œuvre exactement ce bornage : il forme la somme entière exacte de a et b avec l'arithmétique BigInt, la compare à min et max pour la largeur et le caractère signé choisis, et émet le résultat borné avec un booléen saturated et un champ direction valant none, overflow ou underflow, afin que les appelants puissent journaliser ou brancher sans recalculer les bornes eux-mêmes.
Où l'addition saturée est utile
Les développeurs embarqués et DSP utilisent l'addition saturée pour reproduire un comportement de type ARM QADD, des étages de pipeline multimédia et des accumulateurs en virgule fixe sans monter un émulateur complet pour une seule vérification arithmétique. Les outils couleur et audio saturent souvent les sommes de canal ou d'échantillon à huit ou seize bits lors de la prévisualisation de modes de fusion avant d'engager du code de shader.
Les enseignants de la représentation informatique des entiers ont besoin d'un contraste côte à côte entre enroulement modulaire et saturation avec des nombres reproductibles de int8 à int64. Une validation échouée ne consomme pas de solde. Gardez les requêtes compactes, figez result et saturated dans les tests, et vous obtenez des bornages reproductibles pour les devoirs, les oracles CI et les workers en périphérie sans réinventer des tables d'arithmétique à largeur fixe.
Cas d’usage
Contrôles micrologiciel DSP et virgule fixe
Vérifiez l'addition saturée par rapport aux bornes int8/int16/int32 en modélisant des noyaux de type QADD ou des accumulateurs en virgule fixe sans émulateur complet.
Bornage des ressources dans jeux et simulations
Bornez les sommes de santé, dégâts ou score à une largeur de bits choisie pour que le débordement sature au maximum au lieu de s'enrouler en valeur négative.
Questions fréquentes
En quoi l'addition saturée d'entiers diffère-t-elle du débordement normal ?
L'addition à largeur fixe normale s'enroule (arithmétique modulaire). L'addition saturée borne la vraie somme au min ou max représentable pour la largeur et le caractère signé choisis, et ne s'enroule jamais.
Que signifient saturated et direction ?
saturated vaut true lorsque le résultat a été borné. direction vaut overflow si la somme a dépassé max, underflow si elle est passée sous min, et none si aucun bornage n'était nécessaire.
a ou b peuvent-ils être hors de l'intervalle du mot ?
Oui. Les opérandes peuvent être n'importe quels entiers sûrs ; seule la somme est bornée au min/max du mot. Cela correspond à l'usage courant des calculateurs et de l'enseignement pour explorer des entrées hors plage.
Quelles largeurs de bits sont prises en charge ?
Toute largeur de 2 à 64 bits. Par défaut le mot est signé, par exemple de −128 à 127 sur 8 bits ; non signé, l'intervalle part de zéro et monte jusqu'à deux puissance la largeur, moins un.
Pourquoi borner plutôt que laisser la somme reboucler ?
Parce qu'un résultat qui reboucle peut sauter d'une grande valeur positive à une grande valeur négative, une mauvaise surprise en audio, dans les canaux de couleur ou les compteurs de sécurité. Borner retient le résultat à la limite la plus proche, comme le font beaucoup de jeux d'instructions DSP et de codecs multimédias.
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/dev/saturating-add \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"a":100,"b":50,"bits":8}'const res = await fetch("https://api.kit.forhosting.com/dev/saturating-add", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"a": 100,
"b": 50,
"bits": 8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/saturating-add",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"a": 100,
"b": 50,
"bits": 8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/saturating-add", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"a":100,"b":50,"bits":8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"a":100,"b":50,"bits":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/saturating-add", 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
{
"a": 100,
"b": 50,
"bits": 8
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.saturating_add",
"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.
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
Contrat d'entrée, forme de la réponse et comportement d'erreur
Le champ optionnel signed vaut true par défaut pour un mot signé en complément à deux ; mettez signed à false pour un intervalle non signé qui commence à zéro. Des chaînes de type booléen telles que true, false, yes, no, signed et unsigned sont acceptées par commodité. Associez la réponse à vos propres tests unitaires qui figent les chemins saturé et non saturé afin qu'aucune régression de la logique de bornage ne s'infiltre dans un modèle de micrologiciel ou une feuille d'équilibrage de jeu. Envoyez en POST un corps JSON avec les champs obligatoires a et b comme entiers finis (nombres JSON ou chaînes de chiffres avec un signe initial optionnel) dont la valeur absolue reste dans Number.MAX_SAFE_INTEGER, et bits comme entier de deux à soixante-quatre. Champs manquants, non entiers, bits hors de deux à soixante-quatre et valeurs non booléennes de signed échouent avec invalid_input en nommant le problème ; ces échecs ne sont pas facturés. En cas de succès le corps renvoie a, b, bits et signed ; rapporte min et max du mot ; rapporte sum_exact comme la somme mathématique non bornée ; rapporte result comme la valeur bornée ; met saturated à true lorsqu'un bornage a eu lieu ; et fixe direction à none, overflow ou underflow. Les valeurs qui dépassent les entiers sûrs de JavaScript aux extrémités de l'intervalle ou dans la somme exacte sont émises en chaînes décimales pour que le JSON reste exact. Exemple : a égal à cent, b égal à cinquante, bits égal à huit, signed true produit min moins cent vingt-huit, max cent vingt-sept, sum_exact cent cinquante, result cent vingt-sept, saturated true et direction overflow — le cas classique d'addition saturée int8.
Où une API d'addition saturée d'entiers prouve sa valeur
Les auteurs de jeux et de simulations bornent la santé, les dégâts et les compteurs de ressources pour que le débordement n'enroule jamais une jauge presque pleine en une valeur négative ou quasi nulle ; un calculateur public et une API rendent ces règles de bornage révisables dans la documentation de conception. Comme l'implémentation est pure parse de niveau A, chaque appel réussi coûte le prix de base publié $0.002 sans jetons de modèle et sans réseau sortant.
Cas d'intégration
Démonstrations en classe : débordement contre saturation
Montrez aux élèves la différence entre enroulement modulaire et bornage saturé avec min, max, sum_exact et result déterministes pour toute largeur 2–64.
Questions techniques
Quelles largeurs de bits et modes signés sont pris en charge ?
bits doit être un entier de 2 à 64. signed vaut true par défaut (intervalle en complément à deux). Mettez signed false pour l'intervalle non signé [0, 2^bits−1].
Combien coûte le calculateur d'addition saturée d'entiers ?
L'outil navigateur est gratuit. Les requêtes API utilisent le solde KIT prépayé à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.