ForHosting KIT · Mathématiques

Addition de grands entiers

9223372036854775807 plus 1 donne exactement 9223372036854775808, une somme qui déborde un entier signé de 64 bits mais qui est ici conservée chiffre par chiffre. Additionnez deux entiers de toute longueur, sans arrondi ni débordement, et voyez si le résultat tient sur 64 bits. Gratuit dans votre navigateur.

  • Gratuit
  • Fonctionne dans votre navigateur
  • Sans inscription
  • Vos données restent sur votre appareil
Lancer gratuitement Voir l’API
Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Lancer gratuitement

Exemple résolu

Si vous saisissez
Premier texte
9223372036854775807
Second texte
1
Vous obtenez
Sum
9223372036854775808
Nombre de chiffres
19
Signe
positive

Les entiers natifs de soixante-quatre bits cessent d'être exacts dès qu'une somme franchit leur intervalle représentable. Les nombres JavaScript perdent leur identité entière au-delà de neuf quadrillions, les long signés s'enroulent ou lèvent une exception à neuf quintillions, et les registres non signés ne peuvent pas contenir deux à la puissance soixante-quatre. Cette calculatrice d'addition de grands entiers accepte deux entiers décimaux de n'importe quelle longueur, les additionne avec l'arithmétique scolaire de la retenue et renvoie la somme décimale exacte sous forme de chaîne — sans arrondi, sans enroulement et sans notation scientifique. Additionnez le maximum signé de soixante-quatre bits à un et vous recevez 9223372036854775808 ; additionnez deux totaux de grand livre à cent chiffres et chaque chiffre est conservé. Une validation échouée n'est pas facturée.

Pourquoi l'addition native échoue et comment la retenue scolaire reste exacte

Chaque type entier natif courant a un plafond dur. Un mot signé de soixante-quatre bits plafonne à 9223372036854775807 ; en ajouter un l'enroule vers un grand négatif, le sature ou signale un débordement. Une calculatrice d'addition de grands entiers existe pour refuser ce marché.

Chaque opérande est lu comme une chaîne de chiffres décimaux signée, les zéros de tête sont ôtés, et les deux magnitudes sont additionnées depuis le chiffre le moins significatif avec une retenue de zéro ou un, exactement comme sur le papier. Lorsque les signes diffèrent, la plus petite magnitude est soustraite de la plus grande et le signe de la plus grande est conservé ; des magnitudes opposées égales s'annulent à zéro.

Le résultat est réécrit comme une chaîne décimale canonique avec au plus un moins initial et sans signe plus. Parce que chaque étape est une opération finie sur des chiffres, la somme est exacte pour toute longueur jusqu'à la limite de chiffres publiée. Tel est tout l'algorithme : pas de virgule flottante, pas de réduction modulaire, pas de mode d'arrondi.

La capacité indique aussi combien de chiffres occupe la valeur absolue de la somme, si la somme est positive, négative ou nulle, et si elle se situe hors de l'intervalle signé de soixante-quatre bits, afin que les appelants qui doivent encore parler à un système de largeur fixe sachent quand conserver la forme chaîne.

Où l'addition exacte de grands entiers justifie son existence

Les pipelines financiers et de facturation additionnent des lignes de facture, des bases d'impôt et des totaux de sous-unités de crypto-monnaie qui dépassent déjà ce qu'une cellule de tableur ou une colonne monétaire de soixante-quatre bits peut contenir sans arrondir. Les outils de cryptographie et d'encodage additionnent de grands entiers publics, des numéros de série et des compteurs de la taille d'un hachage lorsqu'ils n'ont besoin que d'une somme, pas d'une bibliothèque multiprécision complète.

Les cours d'informatique et les entraînements d'entretien de programmation ont besoin d'un oracle qui démontre la propagation de la retenue sur une chaîne de neuf plus un, et qui refuse de prétendre que 2^63 moins un plus un tient encore dans un long signé. Les scripts de migration de données comparent un SUM de colonnes NUMERIC de la base à ce point d'accès pour détecter un débordement silencieux dans une colonne entière qu'ils s'apprêtent à élargir.

Vous obtenez alors un total exact reproductible pour les grands livres, les correcteurs et les workers de bordure sans dresser un service d'arithmétique à précision arbitraire à vous.

Cas d’usage

Totaux de grand livre et de facture au-delà de soixante-quatre bits

Additionnez deux montants d'argent, d'impôt ou de sous-unité qui débordent déjà un long signé ou une cellule de tableur, et conservez le total décimal exact sous forme de chaîne.

Oracles de débordement pour correcteurs et entretiens

Contrôlez les additionneurs d'étudiants ou de candidats contre une somme scolaire déterministe, y compris une chaîne de neuf plus un et le débordement signé de soixante-quatre bits.

Contrôles de migration avant d'élargir des colonnes entières

Comparez un SUM de base de données à ce total exact pour voir si une colonne tient encore en int64 ou doit devenir un type decimal ou numeric.

Questions fréquentes

Comment additionner deux entiers qui débordent un type de soixante-quatre bits ?

Envoyez a et b comme chaînes de chiffres décimaux (signe initial optionnel).

La calculatrice s'enroule-t-elle ou sature-t-elle en cas de débordement ?

Non. La somme est illimitée dans la limite de chiffres publiée. Il n'y a ni enroulement ni clamp. Pour une addition saturée à largeur fixe, utilisez plutôt un outil dédié aux entiers saturés.

Puis-je additionner un nombre négatif et un nombre positif ?

Oui. Placez un signe moins devant la valeur négative. Quand les signes diffèrent, la plus petite magnitude est soustraite de la plus grande et le signe de la plus grande est conservé ; deux valeurs égales et opposées donnent zéro.

Combien de chiffres chaque nombre peut-il compter ?

Jusqu'à 10 000 chiffres chacun, comptés après suppression des zéros initiaux. Saisissez seulement des chiffres avec un signe plus ou moins facultatif : séparateurs de milliers, espaces, décimales, préfixes hexadécimaux et notation scientifique sont refusés.

Pourquoi un tableur se trompe-t-il sur les très grandes sommes ?

Beaucoup de cellules stockent les nombres en virgule flottante, qui ne peut pas représenter tous les entiers au-delà de 9 007 199 254 740 991 : 10^16 plus un peut déjà être stocké comme 10^16. Ici, les chiffres sont traités comme du texte et tous sont conservés.

Outils associés

Addition poséeMathématiquesVérificateur d'entier palindromeMathématiquesCalculatrice somme n premiers pairsMathématiquesThéorème de la sommeMathématiquesComplément à deuxMathématiquesCalculateur d'addition de complexesMathématiquesPermutation d'éléments identiquesMathématiquesMultiplication poséeMathématiques

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

POSThttps://api.kit.forhosting.com/dev/bignum-add

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/bignum-add \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"a":"9223372036854775807","b":"1"}'

Exemple de requête

{
  "a": "9223372036854775807",
  "b": "1"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.bignum_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

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

max_digits10000

Erreurs

HTTPCodeSignification
401unauthorizedClé API absente ou invalide : vérifiez l’en-tête Authorization.
402insufficient_balanceSolde insuffisant : rechargez votre compte pour lancer cette tâche.
404unknown_typeType de tâche inconnu : vérifiez le champ type de votre requête.
429rate_limitedTrop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

Les appels API réussis utilisent le tarif de base publié $0.002.

Pourquoi l'addition native échoue et comment la retenue scolaire reste exacte

Les doubles IEEE-754, que sont en réalité les nombres JSON et de nombreuses cellules de tableur, perdent la capacité de représenter chaque entier une fois la magnitude passée 9007199254740991, si bien que 10^16 plus un peut déjà être stocké comme 10^16.

Contrat d'entrée, forme de la réponse, limites et erreurs

Les chaînes vides et les champs omis échouent de la même façon. Après lecture du signe, les zéros de tête sont ôtés ; une valeur moins zéro devient zéro. Chaque magnitude déjà élaguée peut contenir au plus 10000 chiffres — cette limite est déclarée et appliquée afin qu'un mur de chiffres collé ne puisse épuiser l'isolat. Les signes mixtes fonctionnent de la même manière : moins cent suivi de vingt zéros, plus un, produit un négatif de dix-neuf chiffres. Les échecs de validation ne sont pas facturés. Envoyez en POST un objet JSON avec deux champs obligatoires, a et b. Chaque champ est un entier décimal : une chaîne de chiffres avec un plus ou un moins initial optionnel, ou un nombre JSON qui est un entier sûr. Les fractions, les séparateurs de milliers, les espaces à l'intérieur des chiffres, les préfixes hexadécimaux et la notation scientifique sont rejetés avec invalid_input en nommant le champ. En cas de succès le corps renvoie les deux opérandes sous forme canonique, retourne sum comme le total décimal exact, digit_count comme le nombre de chiffres de la valeur absolue, sign comme positive, negative ou zero, exceeds_int64 comme true lorsque la somme n'est pas représentable comme entier signé de soixante-quatre bits, et une courte chaîne de formule qui réaffirme sum = a + b. Exemple : a égal à 9223372036854775807 et b égal à 1 produit sum 9223372036854775808, digit_count 19, sign positive et exceeds_int64 true. Les appels API réussis utilisent le tarif de base publié $0.002.

Où l'addition exacte de grands entiers justifie son existence

Parce que l'implémentation est parse de niveau A pur, chaque appel réussi coûte le tarif de base publié $0.002 sans jetons de modèle et sans réseau sortant. Gardez chaque opérande dans la limite de chiffres publiée, envoyez en chaînes plutôt qu'en nombres les valeurs qui feraient déborder JSON, et figez la somme renvoyée dans les tests.

Questions techniques

Pourquoi les grandes valeurs doivent-elles être des chaînes plutôt que des nombres JSON ?

Les nombres JSON sont des doubles IEEE-754. Les entiers plus grands que 9007199254740991 ne sont pas tous représentables, donc une valeur telle que 9223372036854775807 serait déjà arrondie avant l'exécution de l'additionneur. Les chaînes de chiffres restent exactes.

Quelles entrées sont rejetées ?

L'absence de a ou b, les chaînes vides, les fractions, les séparateurs de milliers, les caractères non numériques et les magnitudes de plus de 10000 chiffres échouent avec invalid_input et ne sont pas facturés.

Que coûte la calculatrice d'addition de grands entiers ?

L'outil du navigateur est gratuit. Les requêtes API utilisent un solde KIT prépayé à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.

Consulter la documentation complète du KIT →